@rebuy/rebuy 3.41.0 → 3.43.0

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

@@ -43,6 +43,7 @@ __export(checkout_and_beyond_exports, {
   CABExperiment: () => CABExperiment,
   CABImageSection: () => CABImageSection,
   CABImageSectionFields: () => CABImageSectionFields,
+  CABImageThumbnails: () => CABImageThumbnails,
   CABIntegrations: () => CABIntegrations,
   CABLayoutSection: () => CABLayoutSection,
   CABLayoutWrapping: () => CABLayoutWrapping,
@@ -135,6 +136,7 @@ __export(checkout_and_beyond_exports, {
   VariableType: () => VariableType,
   VariantMode: () => VariantMode,
   VariantSelector: () => VariantSelector,
+  VariantsMode: () => VariantsMode,
   VerticalAlignment: () => VerticalAlignment,
   WidgetType: () => WidgetType,
   bannerColors: () => bannerColors,
@@ -204,13 +206,14 @@ __export(checkout_and_beyond_exports, {
   variableTypes: () => variableTypes,
   variantModes: () => variantModes,
   variantSelectors: () => variantSelectors,
+  variantsModes: () => variantsModes,
   verticalAlignments: () => verticalAlignments,
   widgetTypes: () => widgetTypes
 });
 module.exports = __toCommonJS(checkout_and_beyond_exports);
 
 // src/schema/widgets/checkout-and-beyond/banner.ts
-var import_zod21 = require("zod");
+var import_zod22 = require("zod");
 
 // src/schema/widgets/checkout-and-beyond/common.ts
 var freezeEnum = (values) => Object.freeze(Object.fromEntries(values.map((v) => [v, v])));
@@ -386,6 +389,8 @@ var variableTypes = ["boolean", "number", "text"];
 var VariableType = freezeEnum(variableTypes);
 var variantModes = ["multiple", "single"];
 var VariantMode = freezeEnum(variantModes);
+var variantsModes = [...variantModes, "productGroup"];
+var VariantsMode = freezeEnum(variantsModes);
 var variantSelectors = ["menu", "radio", "button"];
 var VariantSelector = freezeEnum(variantSelectors);
 var verticalAlignments = ["top", "middle", "bottom"];
@@ -420,18 +425,18 @@ var WidgetType = freezeEnum(widgetTypes);
 
 // src/schema/widgets/checkout-and-beyond/layout.ts
 var import_uuid13 = require("uuid");
-var import_zod20 = require("zod");
+var import_zod21 = require("zod");
 
 // src/schema/widgets/checkout-and-beyond/shared.ts
-var import_zod19 = require("zod");
+var import_zod20 = require("zod");
 
 // src/schema/widgets/checkout-and-beyond/button.ts
 var import_uuid3 = require("uuid");
-var import_zod5 = require("zod");
+var import_zod6 = require("zod");
 
 // src/schema/widgets/checkout-and-beyond/image.ts
 var import_uuid = require("uuid");
-var import_zod3 = require("zod");
+var import_zod4 = require("zod");
 
 // src/schema/widgets/checkout-and-beyond/icons.ts
 var iconNames = [
@@ -517,6 +522,13 @@ var IconSize = freezeEnum(iconSizes);
 var iconTones = ["auto", "critical", "custom", "info", "neutral", "success", "warning"];
 var IconTone = freezeEnum(iconTones);
 
+// src/schema/widgets/checkout-and-beyond/imageThumbnails.ts
+var import_zod = require("zod");
+var CABImageThumbnails = import_zod.z.object({
+  limit: import_zod.z.number().int().min(1).default(8),
+  perLine: import_zod.z.number().int().min(1).max(8).default(4)
+});
+
 // src/schema/widgets/checkout-and-beyond/regex.ts
 var ARRAY_INDEX_STRING = /^(0|[1-9]\d*)$/;
 var DYNAMIC_TOKEN_REGEX = /^\{\{\s*[A-Za-z]+\s*\}\}$/;
@@ -593,10 +605,10 @@ var isTextType = isSectionType(SectionType.text);
 var isVariantsType = isSectionType(SectionType.variants);
 
 // src/schema/widgets/checkout-and-beyond/variables.ts
-var import_zod2 = require("zod");
+var import_zod3 = require("zod");
 
 // src/schema/widgets/checkout-and-beyond/rule.ts
-var import_zod = require("zod");
+var import_zod2 = require("zod");
 var ruleTypes = [
   "cart",
   "cart_count",
@@ -615,7 +627,7 @@ var ruleTypes = [
   "product_type",
   "product_vendor"
 ];
-var ruleType = import_zod.z.enum(ruleTypes);
+var ruleType = import_zod2.z.enum(ruleTypes);
 var RuleType = ruleType.enum;
 var ruleOperators = [
   "after",
@@ -630,124 +642,124 @@ var ruleOperators = [
   "greater_than",
   "less_than"
 ];
-var ruleOperator = import_zod.z.enum(ruleOperators);
+var ruleOperator = import_zod2.z.enum(ruleOperators);
 var RuleOperator = ruleOperator.enum;
-var RuleCondition = import_zod.z.object({
-  operator: import_zod.z.enum(ruleOperators).default(RuleOperator.anything),
-  products: import_zod.z.union([import_zod.z.array(import_zod.z.unknown()), import_zod.z.strictObject({}).transform(() => [])]).default(() => []),
-  type: import_zod.z.enum(ruleTypes).default(RuleType.cart_subtotal),
-  value: import_zod.z.coerce.string().default("")
+var RuleCondition = import_zod2.z.object({
+  operator: import_zod2.z.enum(ruleOperators).default(RuleOperator.anything),
+  products: import_zod2.z.union([import_zod2.z.array(import_zod2.z.unknown()), import_zod2.z.strictObject({}).transform(() => [])]).default(() => []),
+  type: import_zod2.z.enum(ruleTypes).default(RuleType.cart_subtotal),
+  value: import_zod2.z.coerce.string().default("")
 });
-var RuleLogicBlock = import_zod.z.object({
-  rules: import_zod.z.array(RuleCondition).default(() => [])
+var RuleLogicBlock = import_zod2.z.object({
+  rules: import_zod2.z.array(RuleCondition).default(() => [])
 });
-var CABRulesetEntry = import_zod.z.object({
-  exitIfMatched: import_zod.z.boolean().default(true),
-  logic: import_zod.z.array(RuleLogicBlock).default(() => []),
-  output: import_zod.z.array(
-    import_zod.z.object({
-      key: import_zod.z.string().default("should_show"),
-      type: import_zod.z.literal("data_json").default("data_json"),
-      value: import_zod.z.string().default("true")
+var CABRulesetEntry = import_zod2.z.object({
+  exitIfMatched: import_zod2.z.boolean().default(true),
+  logic: import_zod2.z.array(RuleLogicBlock).default(() => []),
+  output: import_zod2.z.array(
+    import_zod2.z.object({
+      key: import_zod2.z.string().default("should_show"),
+      type: import_zod2.z.literal("data_json").default("data_json"),
+      value: import_zod2.z.string().default("true")
     })
   ).default(() => [{ key: "should_show", type: "data_json", value: "true" }])
 });
-var CABRuleset = import_zod.z.union([import_zod.z.array(CABRulesetEntry), import_zod.z.strictObject({}).transform(() => [])]).default(() => []);
+var CABRuleset = import_zod2.z.union([import_zod2.z.array(CABRulesetEntry), import_zod2.z.strictObject({}).transform(() => [])]).default(() => []);
 
 // src/schema/widgets/checkout-and-beyond/variables.ts
-var variableEffect = import_zod2.z.enum(variableEffects);
-var CABVariableSeed = import_zod2.z.object({
-  dataSourceId: import_zod2.z.number().nullable().default(null),
+var variableEffect = import_zod3.z.enum(variableEffects);
+var CABVariableSeed = import_zod3.z.object({
+  dataSourceId: import_zod3.z.number().nullable().default(null),
   ruleset: CABRuleset
 });
-var CABBooleanVariable = import_zod2.z.object({
+var CABBooleanVariable = import_zod3.z.object({
   /**
    * Holds until the first seed verdict lands (and forever, for unseeded variables). Omitted, it derives
    * from seededness — `false` with a `seed` (visibility is EARNED), `true` without — via the transform
    * below; a cross-field default has no `.default()` spelling. An explicit value always wins.
    */
-  defaultValue: import_zod2.z.boolean().optional(),
-  name: import_zod2.z.string().min(1),
+  defaultValue: import_zod3.z.boolean().optional(),
+  name: import_zod3.z.string().min(1),
   seed: CABVariableSeed.optional(),
   /** Defaulted so every stored declaration (all boolean before `text` existed) parses unchanged. */
-  type: import_zod2.z.literal(VariableType.boolean).default(VariableType.boolean)
+  type: import_zod3.z.literal(VariableType.boolean).default(VariableType.boolean)
 });
-var CABTextVariable = import_zod2.z.object({
-  defaultValue: import_zod2.z.string(),
-  name: import_zod2.z.string().min(1),
-  seed: import_zod2.z.never().optional(),
-  type: import_zod2.z.literal(VariableType.text)
+var CABTextVariable = import_zod3.z.object({
+  defaultValue: import_zod3.z.string(),
+  name: import_zod3.z.string().min(1),
+  seed: import_zod3.z.never().optional(),
+  type: import_zod3.z.literal(VariableType.text)
 });
-var CABNumberVariable = import_zod2.z.object({
-  defaultValue: import_zod2.z.number(),
-  name: import_zod2.z.string().min(1),
-  seed: import_zod2.z.never().optional(),
-  type: import_zod2.z.literal(VariableType.number)
+var CABNumberVariable = import_zod3.z.object({
+  defaultValue: import_zod3.z.number(),
+  name: import_zod3.z.string().min(1),
+  seed: import_zod3.z.never().optional(),
+  type: import_zod3.z.literal(VariableType.number)
 });
-var CABVariable = import_zod2.z.union([CABTextVariable, CABNumberVariable, CABBooleanVariable]).transform(
+var CABVariable = import_zod3.z.union([CABTextVariable, CABNumberVariable, CABBooleanVariable]).transform(
   (variable) => variable.type === VariableType.boolean ? { ...variable, defaultValue: variable.defaultValue ?? variable.seed === void 0 } : variable
 );
-var CABVariableEffect = import_zod2.z.object({
+var CABVariableEffect = import_zod3.z.object({
   effect: variableEffect.default(VariableEffect.toggle),
-  variable: import_zod2.z.string().min(1)
+  variable: import_zod3.z.string().min(1)
 });
-var CABVisibility = import_zod2.z.object({
-  variable: import_zod2.z.string().min(1),
-  visibleWhen: import_zod2.z.boolean().default(true)
+var CABVisibility = import_zod3.z.object({
+  variable: import_zod3.z.string().min(1),
+  visibleWhen: import_zod3.z.boolean().default(true)
 });
-var contentOperator = import_zod2.z.enum(contentOperators);
-var resultCountOperator = import_zod2.z.enum(resultCountOperators);
-var resultTagOperator = import_zod2.z.enum(resultTagOperators);
-var mutatorEvent = import_zod2.z.enum(mutatorEvents);
-var CABContentTrigger = import_zod2.z.object({
+var contentOperator = import_zod3.z.enum(contentOperators);
+var resultCountOperator = import_zod3.z.enum(resultCountOperators);
+var resultTagOperator = import_zod3.z.enum(resultTagOperators);
+var mutatorEvent = import_zod3.z.enum(mutatorEvents);
+var CABContentTrigger = import_zod3.z.object({
   operator: contentOperator.default(ContentOperator.is_empty),
-  type: import_zod2.z.literal("content")
+  type: import_zod3.z.literal("content")
 });
-var CABResultCountTrigger = import_zod2.z.object({
+var CABResultCountTrigger = import_zod3.z.object({
   operator: resultCountOperator.default(ResultCountOperator.equals),
-  type: import_zod2.z.literal("result_count"),
-  value: import_zod2.z.number().default(0)
+  type: import_zod3.z.literal("result_count"),
+  value: import_zod3.z.number().default(0)
 });
-var CABResultTagTrigger = import_zod2.z.object({
+var CABResultTagTrigger = import_zod3.z.object({
   operator: resultTagOperator.default(ResultTagOperator.contains),
-  type: import_zod2.z.literal("result_tag"),
-  value: import_zod2.z.string().min(1)
+  type: import_zod3.z.literal("result_tag"),
+  value: import_zod3.z.string().min(1)
 });
-var CABEventTrigger = import_zod2.z.object({
+var CABEventTrigger = import_zod3.z.object({
   event: mutatorEvent,
-  type: import_zod2.z.literal("event")
+  type: import_zod3.z.literal("event")
 });
-var CABVariableTrigger = import_zod2.z.discriminatedUnion("type", [
+var CABVariableTrigger = import_zod3.z.discriminatedUnion("type", [
   CABContentTrigger,
   CABEventTrigger,
   CABResultCountTrigger,
   CABResultTagTrigger
 ]);
-var CABVariableMutator = import_zod2.z.object({
+var CABVariableMutator = import_zod3.z.object({
   effect: variableEffect.default(VariableEffect.set_false),
-  variable: import_zod2.z.string().min(1),
+  variable: import_zod3.z.string().min(1),
   when: CABVariableTrigger
 });
 var CABVariableFields = {
-  mutators: import_zod2.z.array(CABVariableMutator).optional(),
-  variables: import_zod2.z.array(CABVariable).refine((variables) => new Set(variables.map(({ name }) => name)).size === variables.length, {
+  mutators: import_zod3.z.array(CABVariableMutator).optional(),
+  variables: import_zod3.z.array(CABVariable).refine((variables) => new Set(variables.map(({ name }) => name)).size === variables.length, {
     message: "variable names must be unique within a section"
   }).optional(),
   visibility: CABVisibility.optional()
 };
 
 // src/schema/widgets/checkout-and-beyond/image.ts
-var CABImageSectionFields = import_zod3.z.object({
+var CABImageSectionFields = import_zod4.z.object({
   ...CABVariableFields,
-  altText: import_zod3.z.string().refine(checkForHTML, NO_HTML).default(""),
+  altText: import_zod4.z.string().refine(checkForHTML, NO_HTML).default(""),
   /**
    * Image width÷height (e.g. `46` for the progress-bar fill); `null` renders at natural size. Any POSITIVE
    * ratio — never limited to 1, but never `0`/negative either: a renderer dividing by it would get `Infinity`,
    * and CSS `aspect-ratio` drops a negative value and silently reverts to natural size.
    */
-  aspectRatio: import_zod3.z.number().positive().nullable().default(null),
-  border: import_zod3.z.lazy(() => CABBorder),
-  buttonField: import_zod3.z.enum(buttonFields).optional(),
+  aspectRatio: import_zod4.z.number().positive().nullable().default(null),
+  border: import_zod4.z.lazy(() => CABBorder),
+  buttonField: import_zod4.z.enum(buttonFields).optional(),
   /**
    * `icon` renders `source` as a single `s-icon` by name (the uber-image path covers icons too), reading
    * `iconSize`/`iconTone`. The other values are a harmless informational holdover from the previous
@@ -766,29 +778,30 @@ var CABImageSectionFields = import_zod3.z.object({
    * behavior degraded gracefully and told us about it. The client-assembled half of the invariant was never
    * the risky half.
    */
-  category: import_zod3.z.enum(["gallery", "icon", "icons", "payment-methods", "secure-checkout"]).nullable().default(null),
+  category: import_zod4.z.enum(["gallery", "icon", "icons", "payment-methods", "secure-checkout"]).nullable().default(null),
   /** `icon`-mode only: the `s-icon` `size`; `null` ⇒ the component default (`base`). Ignored by image treatments. */
-  iconSize: import_zod3.z.enum(iconSizes).nullable().default(null),
+  iconSize: import_zod4.z.enum(iconSizes).nullable().default(null),
   /** `icon`-mode only: the `s-icon` `tone`; `null` ⇒ the component default (`auto`). Ignored by image treatments. */
-  iconTone: import_zod3.z.enum(iconTones).nullable().default(null),
-  name: import_zod3.z.string().optional(),
-  naturalHeight: import_zod3.z.number().default(0),
-  naturalWidth: import_zod3.z.number().default(0),
+  iconTone: import_zod4.z.enum(iconTones).nullable().default(null),
+  name: import_zod4.z.string().optional(),
+  naturalHeight: import_zod4.z.number().default(0),
+  naturalWidth: import_zod4.z.number().default(0),
   /**
    * `contain` (the component default): dimensionless images render in s-image's 1/1 default frame, and
    * `cover` would crop non-square art (payment badges lost their edges — 15993); `contain` letterboxes.
    */
-  objectFit: import_zod3.z.enum(objectFits).default(ObjectFit.contain),
-  sectionId: import_zod3.z.uuid().default(() => (0, import_uuid.v7)()),
-  sectionType: import_zod3.z.literal(SectionType.image).default(SectionType.image),
+  objectFit: import_zod4.z.enum(objectFits).default(ObjectFit.contain),
+  sectionId: import_zod4.z.uuid().default(() => (0, import_uuid.v7)()),
+  sectionType: import_zod4.z.literal(SectionType.image).default(SectionType.image),
   /**
    * An image URL or dynamic token, an empty default, or — when `category: 'icon'` — an icon NAME. Icon mode
    * takes a name or `''` only, NOT a token: no renderer resolves a token to an icon today, so accepting one
    * would promise a capability that doesn't exist. Widen the refine's carve-out to `DYNAMIC_TOKEN_REGEX` when a
    * server-chosen tier icon actually needs it.
    */
-  source: import_zod3.z.union([import_zod3.z.url(), import_zod3.z.literal(""), import_zod3.z.string().regex(DYNAMIC_TOKEN_REGEX), import_zod3.z.enum(iconNames)]).default(""),
-  width: import_zod3.z.number().default(100)
+  source: import_zod4.z.union([import_zod4.z.url(), import_zod4.z.literal(""), import_zod4.z.string().regex(DYNAMIC_TOKEN_REGEX), import_zod4.z.enum(iconNames)]).default(""),
+  thumbnails: CABImageThumbnails.optional(),
+  width: import_zod4.z.number().default(100)
 });
 var iconNameSet = new Set(iconNames);
 var isIconName = (source) => iconNameSet.has(source);
@@ -810,71 +823,71 @@ var CABImageSection = CABImageSectionFields.superRefine(({ category, source }, c
 // src/schema/widgets/checkout-and-beyond/text.ts
 var import_compat2 = require("es-toolkit/compat");
 var import_uuid2 = require("uuid");
-var import_zod4 = require("zod");
-var enumOrOmit = (...vals) => import_zod4.z.string().transform((val) => vals.includes(val) ? val : void 0).optional();
-var TiptapText = import_zod4.z.object({
-  marks: import_zod4.z.union([
-    import_zod4.z.array(
-      import_zod4.z.discriminatedUnion("type", [
-        import_zod4.z.object({ type: import_zod4.z.literal("bold") }),
-        import_zod4.z.object({ type: import_zod4.z.literal("italic") }),
-        import_zod4.z.object({
-          attrs: import_zod4.z.object({
-            class: import_zod4.z.string().nullable(),
-            href: import_zod4.z.union([
-              import_zod4.z.url(),
-              import_zod4.z.literal("#"),
-              import_zod4.z.string().regex(DYNAMIC_TOKEN_REGEX),
-              import_zod4.z.string().regex(ROOT_RELATIVE_PATH_REGEX)
+var import_zod5 = require("zod");
+var enumOrOmit = (...vals) => import_zod5.z.string().transform((val) => vals.includes(val) ? val : void 0).optional();
+var TiptapText = import_zod5.z.object({
+  marks: import_zod5.z.union([
+    import_zod5.z.array(
+      import_zod5.z.discriminatedUnion("type", [
+        import_zod5.z.object({ type: import_zod5.z.literal("bold") }),
+        import_zod5.z.object({ type: import_zod5.z.literal("italic") }),
+        import_zod5.z.object({
+          attrs: import_zod5.z.object({
+            class: import_zod5.z.string().nullable(),
+            href: import_zod5.z.union([
+              import_zod5.z.url(),
+              import_zod5.z.literal("#"),
+              import_zod5.z.string().regex(DYNAMIC_TOKEN_REGEX),
+              import_zod5.z.string().regex(ROOT_RELATIVE_PATH_REGEX)
             ]),
-            rel: import_zod4.z.string().default("noopener noreferrer nofollow"),
-            target: import_zod4.z.string().default("_blank")
+            rel: import_zod5.z.string().default("noopener noreferrer nofollow"),
+            target: import_zod5.z.string().default("_blank")
           }),
-          type: import_zod4.z.literal("link")
+          type: import_zod5.z.literal("link")
         }),
-        import_zod4.z.object({ type: import_zod4.z.literal("strike") }),
-        import_zod4.z.object({
-          attrs: import_zod4.z.object({
+        import_zod5.z.object({ type: import_zod5.z.literal("strike") }),
+        import_zod5.z.object({
+          attrs: import_zod5.z.object({
             color: enumOrOmit(...textColorNames).default(TextColorName.base),
             fontSize: enumOrOmit(...textSizeNames).default(TextSizeName.base)
           }),
-          type: import_zod4.z.literal("textStyle")
+          type: import_zod5.z.literal("textStyle")
         })
       ])
     ),
-    import_zod4.z.strictObject({}).transform(() => [])
+    import_zod5.z.strictObject({}).transform(() => [])
   ]).optional(),
-  text: import_zod4.z.string().default(""),
-  type: import_zod4.z.literal("text").default("text")
+  text: import_zod5.z.string().default(""),
+  type: import_zod5.z.literal("text").default("text")
 });
-var TiptapParagraph = import_zod4.z.object({
-  attrs: import_zod4.z.object({
+var TiptapParagraph = import_zod5.z.object({
+  attrs: import_zod5.z.object({
     textAlign: enumOrOmit(...textAlignments)
   }).default({ textAlign: TextAlignment.start }),
-  content: import_zod4.z.union([import_zod4.z.array(TiptapText), import_zod4.z.strictObject({}).transform(() => [])]).default(() => []),
-  type: import_zod4.z.literal("paragraph").default("paragraph")
+  content: import_zod5.z.union([import_zod5.z.array(TiptapText), import_zod5.z.strictObject({}).transform(() => [])]).default(() => []),
+  type: import_zod5.z.literal("paragraph").default("paragraph")
 });
-var TiptapDocument = import_zod4.z.object({
-  attrs: import_zod4.z.object({
+var TiptapDocument = import_zod5.z.object({
+  attrs: import_zod5.z.object({
     blockSpacing: enumOrOmit(...spacings)
   }).default({ blockSpacing: Spacing.base }),
-  content: import_zod4.z.union([import_zod4.z.array(TiptapParagraph), import_zod4.z.strictObject({}).transform(() => [])]).default(() => [TiptapParagraph.parse({})]),
-  type: import_zod4.z.literal("doc").default("doc")
+  content: import_zod5.z.union([import_zod5.z.array(TiptapParagraph), import_zod5.z.strictObject({}).transform(() => [])]).default(() => [TiptapParagraph.parse({})]),
+  type: import_zod5.z.literal("doc").default("doc")
 });
-var CABTextTier = import_zod4.z.object({
-  threshold: import_zod4.z.number().int().nonnegative(),
-  thresholds: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.number().int().nonnegative()).default(() => ({})),
-  tierId: import_zod4.z.string().optional(),
-  tierType: import_zod4.z.enum(progressTierTypes).default(ProgressTierType.shipping)
+var CABTextTier = import_zod5.z.object({
+  threshold: import_zod5.z.number().int().nonnegative(),
+  thresholds: import_zod5.z.record(import_zod5.z.string(), import_zod5.z.number().int().nonnegative()).default(() => ({})),
+  tierId: import_zod5.z.string().optional(),
+  tierType: import_zod5.z.enum(progressTierTypes).default(ProgressTierType.shipping)
 });
-var CABTextSection = import_zod4.z.object({
+var CABTextSection = import_zod5.z.object({
   ...CABVariableFields,
-  buttonField: import_zod4.z.enum(buttonFields).optional(),
-  content: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.union([import_zod4.z.string(), TiptapDocument]).refine(checkForHTML, NO_HTML).optional()).default({ en: TiptapDocument.parse({}) }).optional(),
-  name: import_zod4.z.string().optional(),
-  optionId: import_zod4.z.number().optional(),
-  sectionId: import_zod4.z.uuid().default(() => (0, import_uuid2.v7)()),
-  sectionType: import_zod4.z.literal(SectionType.text).default(SectionType.text),
+  buttonField: import_zod5.z.enum(buttonFields).optional(),
+  content: import_zod5.z.record(import_zod5.z.string(), import_zod5.z.union([import_zod5.z.string(), TiptapDocument]).refine(checkForHTML, NO_HTML).optional()).default({ en: TiptapDocument.parse({}) }).optional(),
+  name: import_zod5.z.string().optional(),
+  optionId: import_zod5.z.number().optional(),
+  sectionId: import_zod5.z.uuid().default(() => (0, import_uuid2.v7)()),
+  sectionType: import_zod5.z.literal(SectionType.text).default(SectionType.text),
   tier: CABTextTier.optional()
 }).superRefine(({ buttonField, content }, ctx) => {
   if (buttonField === ButtonField.destinationUrl && content) {
@@ -896,35 +909,35 @@ var CABTextSection = import_zod4.z.object({
 });
 
 // src/schema/widgets/checkout-and-beyond/button.ts
-var CABButtonContent = import_zod5.z.lazy(
-  () => import_zod5.z.discriminatedUnion("sectionType", [CABImageSection, CABLayoutSection, CABTextSection])
+var CABButtonContent = import_zod6.z.lazy(
+  () => import_zod6.z.discriminatedUnion("sectionType", [CABImageSection, CABLayoutSection, CABTextSection])
 );
-var CABButtonSection = import_zod5.z.object({
+var CABButtonSection = import_zod6.z.object({
   ...CABVariableFields,
-  action: import_zod5.z.union([import_zod5.z.literal(""), import_zod5.z.enum(buttonActions)]).default(""),
-  buttonStyle: import_zod5.z.enum(buttonStyles).default(ButtonStyle.primary),
-  custom: import_zod5.z.object({
-    color: import_zod5.z.string().regex(HEX_COLOR_REGEX).default("#005bd3"),
-    height: import_zod5.z.number().default(52),
-    width: import_zod5.z.number().default(300)
+  action: import_zod6.z.union([import_zod6.z.literal(""), import_zod6.z.enum(buttonActions)]).default(""),
+  buttonStyle: import_zod6.z.enum(buttonStyles).default(ButtonStyle.primary),
+  custom: import_zod6.z.object({
+    color: import_zod6.z.string().regex(HEX_COLOR_REGEX).default("#005bd3"),
+    height: import_zod6.z.number().default(52),
+    width: import_zod6.z.number().default(300)
   }).default({
     color: "#005bd3",
     height: 52,
     width: 300
   }),
-  disableDowngrade: import_zod5.z.boolean().default(false),
-  name: import_zod5.z.string().optional(),
-  optionId: import_zod5.z.number().optional(),
-  popover: import_zod5.z.object({
-    alignment: import_zod5.z.enum(textAlignments).default(TextAlignment.center),
-    position: import_zod5.z.enum(popoverPositions).default(PopoverPosition.blockStart)
+  disableDowngrade: import_zod6.z.boolean().default(false),
+  name: import_zod6.z.string().optional(),
+  optionId: import_zod6.z.number().optional(),
+  popover: import_zod6.z.object({
+    alignment: import_zod6.z.enum(textAlignments).default(TextAlignment.center),
+    position: import_zod6.z.enum(popoverPositions).default(PopoverPosition.blockStart)
   }).optional().default(() => ({
     alignment: TextAlignment.center,
     position: PopoverPosition.blockStart
   })),
-  sectionId: import_zod5.z.uuid().default(() => (0, import_uuid3.v7)()),
-  sections: import_zod5.z.union([import_zod5.z.array(CABButtonContent), import_zod5.z.strictObject({}).transform(() => [])]).default(() => []),
-  sectionType: import_zod5.z.literal(SectionType.button).default(SectionType.button),
+  sectionId: import_zod6.z.uuid().default(() => (0, import_uuid3.v7)()),
+  sections: import_zod6.z.union([import_zod6.z.array(CABButtonContent), import_zod6.z.strictObject({}).transform(() => [])]).default(() => []),
+  sectionType: import_zod6.z.literal(SectionType.button).default(SectionType.button),
   /**
    * The smart-cart tier this button acts on (`addGift`/`removeGift`): scopes the click to one tier's gift. The
    * client resolves the tier's gift (productId) from the progress-bar context by this `tierId` — the button node
@@ -939,25 +952,25 @@ var CABButtonSection = import_zod5.z.object({
    * lookup finds no tier and the click resolves to nothing. Safe to bound — the field is new, so there are no
    * stored payloads to grandfather, and the producer is client code, not a merchant form.
    */
-  tier: import_zod5.z.object({ tierId: import_zod5.z.string().min(1) }).optional(),
+  tier: import_zod6.z.object({ tierId: import_zod6.z.string().min(1) }).optional(),
   /** Fire-and-forget pixel POSTed when the button is clicked (e.g. a Monetize decline). */
-  trackingUrl: import_zod5.z.string().optional(),
+  trackingUrl: import_zod6.z.string().optional(),
   /**
    * Secondary effects applied to in-scope variables on click, alongside (never instead of) the primary
    * `action` — an `addToOrder` button can also flip a variable. Applied in array order.
    */
-  variableEffects: import_zod5.z.array(CABVariableEffect).optional()
+  variableEffects: import_zod6.z.array(CABVariableEffect).optional()
 });
 
 // src/schema/widgets/checkout-and-beyond/carousel.ts
-var import_zod10 = require("zod");
+var import_zod11 = require("zod");
 
 // src/schema/widgets/checkout-and-beyond/offers.ts
-var import_zod9 = require("zod");
+var import_zod10 = require("zod");
 
 // src/schema/widgets/checkout-and-beyond/dataSource.ts
 var import_uuid4 = require("uuid");
-var import_zod6 = require("zod");
+var import_zod7 = require("zod");
 
 // src/schema/widgets/checkout-and-beyond/constants.ts
 var import_es_toolkit3 = require("es-toolkit");
@@ -1011,77 +1024,77 @@ var targetAreas = {
 };
 
 // src/schema/widgets/checkout-and-beyond/dataSource.ts
-var CABDiscount = import_zod6.z.object({
-  amount: import_zod6.z.union([import_zod6.z.number(), import_zod6.z.string()]).catch(0),
-  discountedBy: import_zod6.z.string().optional(),
-  discountedFrom: import_zod6.z.enum(discountSources).optional().catch(void 0),
-  type: import_zod6.z.enum(discountTypes).catch("none")
+var CABDiscount = import_zod7.z.object({
+  amount: import_zod7.z.union([import_zod7.z.number(), import_zod7.z.string()]).catch(0),
+  discountedBy: import_zod7.z.string().optional(),
+  discountedFrom: import_zod7.z.enum(discountSources).optional().catch(void 0),
+  type: import_zod7.z.enum(discountTypes).catch("none")
 });
-var CABIntegrations = import_zod6.z.object({
-  judgeme: import_zod6.z.boolean().default(false),
-  junip: import_zod6.z.boolean().default(false),
-  klaviyo: import_zod6.z.boolean().default(false),
-  loox: import_zod6.z.boolean().default(false),
-  okendo: import_zod6.z.boolean().default(false),
-  opinew: import_zod6.z.boolean().default(false),
-  reviewsio: import_zod6.z.boolean().default(false),
-  stamped: import_zod6.z.boolean().default(false),
-  yotpo: import_zod6.z.boolean().default(false)
+var CABIntegrations = import_zod7.z.object({
+  judgeme: import_zod7.z.boolean().default(false),
+  junip: import_zod7.z.boolean().default(false),
+  klaviyo: import_zod7.z.boolean().default(false),
+  loox: import_zod7.z.boolean().default(false),
+  okendo: import_zod7.z.boolean().default(false),
+  opinew: import_zod7.z.boolean().default(false),
+  reviewsio: import_zod7.z.boolean().default(false),
+  stamped: import_zod7.z.boolean().default(false),
+  yotpo: import_zod7.z.boolean().default(false)
 });
-var CABVariantLabels = import_zod6.z.object({
-  variantOption: import_zod6.z.string().optional().catch(void 0),
-  variantOptions: import_zod6.z.string().optional().catch(void 0)
+var CABVariantLabels = import_zod7.z.object({
+  variantOption: import_zod7.z.string().optional().catch(void 0),
+  variantOptions: import_zod7.z.string().optional().catch(void 0)
 });
-var CABDataSourceSection = import_zod6.z.object({
-  dataSourceId: import_zod6.z.number().nullable().default(null),
-  dataSourcePath: import_zod6.z.string().default(DEFAULT_ENDPOINTS[0].value),
+var CABDataSourceSection = import_zod7.z.object({
+  dataSourceId: import_zod7.z.number().nullable().default(null),
+  dataSourcePath: import_zod7.z.string().default(DEFAULT_ENDPOINTS[0].value),
   discount: CABDiscount.optional(),
   integrations: CABIntegrations.optional(),
-  limit: import_zod6.z.number().default(1),
-  matchVariant: import_zod6.z.boolean().default(false),
-  matchVariantOutOfStock: import_zod6.z.boolean().default(false),
-  name: import_zod6.z.string().default(DEFAULT_ENDPOINTS[0].label),
-  productType: import_zod6.z.enum(productTypes).optional(),
-  sectionId: import_zod6.z.uuid().default(() => (0, import_uuid4.v7)()),
-  sectionType: import_zod6.z.literal(SectionType.dataSource).default(SectionType.dataSource),
+  limit: import_zod7.z.number().default(1),
+  matchVariant: import_zod7.z.boolean().default(false),
+  matchVariantOutOfStock: import_zod7.z.boolean().default(false),
+  name: import_zod7.z.string().default(DEFAULT_ENDPOINTS[0].label),
+  productType: import_zod7.z.enum(productTypes).optional(),
+  sectionId: import_zod7.z.uuid().default(() => (0, import_uuid4.v7)()),
+  sectionType: import_zod7.z.literal(SectionType.dataSource).default(SectionType.dataSource),
   /** Default subscribe-vs-one-time for `productType: both` (legacy `subscription_is_default`). */
-  subscriptionIsDefault: import_zod6.z.boolean().default(false),
-  treatAsGwp: import_zod6.z.boolean().default(false),
+  subscriptionIsDefault: import_zod7.z.boolean().default(false),
+  treatAsGwp: import_zod7.z.boolean().default(false),
   variantLabels: CABVariantLabels.optional().catch(void 0)
 });
 
 // src/schema/widgets/checkout-and-beyond/products.ts
 var import_uuid6 = require("uuid");
-var import_zod8 = require("zod");
+var import_zod9 = require("zod");
 
 // src/schema/widgets/checkout-and-beyond/product.ts
 var import_uuid5 = require("uuid");
-var import_zod7 = require("zod");
-var CABVariantContent = import_zod7.z.lazy(
-  () => import_zod7.z.discriminatedUnion("sectionType", [CABButtonSection, CABTextSection])
+var import_zod8 = require("zod");
+var CABVariantContent = import_zod8.z.lazy(
+  () => import_zod8.z.discriminatedUnion("sectionType", [CABButtonSection, CABTextSection])
 );
-var CABProductSection = import_zod7.z.object({
+var CABProductSection = import_zod8.z.object({
   ...CABVariableFields,
-  name: import_zod7.z.string().optional(),
-  productId: import_zod7.z.number().nullable().default(null),
-  sectionId: import_zod7.z.uuid().default(() => (0, import_uuid5.v7)()),
-  sections: import_zod7.z.union([import_zod7.z.array(CABVariantContent), import_zod7.z.strictObject({}).transform(() => [])]).default(() => []),
-  sectionType: import_zod7.z.literal(SectionType.product).default(SectionType.product),
-  selectors: import_zod7.z.record(import_zod7.z.string(), import_zod7.z.enum(variantSelectors).default(VariantSelector.menu)).default(() => ({})),
-  variantMode: import_zod7.z.enum(variantModes).default(VariantMode.multiple)
+  name: import_zod8.z.string().optional(),
+  productId: import_zod8.z.number().nullable().default(null),
+  sectionId: import_zod8.z.uuid().default(() => (0, import_uuid5.v7)()),
+  sections: import_zod8.z.union([import_zod8.z.array(CABVariantContent), import_zod8.z.strictObject({}).transform(() => [])]).default(() => []),
+  sectionType: import_zod8.z.literal(SectionType.product).default(SectionType.product),
+  selectors: import_zod8.z.record(import_zod8.z.string(), import_zod8.z.enum(variantSelectors).default(VariantSelector.menu)).default(() => ({})),
+  variantMode: import_zod8.z.enum(variantModes).default(VariantMode.multiple)
 });
 
 // src/schema/widgets/checkout-and-beyond/products.ts
-var CABProductsSection = import_zod8.z.object({
+var CABProductsSection = import_zod9.z.object({
   ...CABVariableFields,
-  name: import_zod8.z.string().optional(),
-  sectionId: import_zod8.z.uuid().default(() => (0, import_uuid6.v7)()),
-  sections: import_zod8.z.union([import_zod8.z.array(import_zod8.z.lazy(() => CABProductSection)), import_zod8.z.strictObject({}).transform(() => [])]).default(() => []),
-  sectionType: import_zod8.z.literal(SectionType.products).default(SectionType.products)
+  name: import_zod9.z.string().optional(),
+  sectionId: import_zod9.z.uuid().default(() => (0, import_uuid6.v7)()),
+  sections: import_zod9.z.union([import_zod9.z.array(import_zod9.z.lazy(() => CABProductSection)), import_zod9.z.strictObject({}).transform(() => [])]).default(() => []),
+  sectionType: import_zod9.z.literal(SectionType.products).default(SectionType.products)
 });
 
 // src/schema/widgets/checkout-and-beyond/offers.ts
-var CABOffersSection = import_zod9.z.lazy(
+var CABOffersSection = import_zod10.z.lazy(
   () => CABLayoutSection.omit({ sections: true, sectionType: true }).extend({
     /**
      * A rule between consecutive cards in the vertical list — legacy checkout-offers' `<Divider />`,
@@ -1089,8 +1102,8 @@ var CABOffersSection = import_zod9.z.lazy(
      * run of products). Optional, not defaulted: only the v1 converter sets it (REB-24265); a
      * hand-built tree keeps React CAB's dividerless rendering.
      */
-    divider: import_zod9.z.boolean().optional(),
-    sections: import_zod9.z.union([import_zod9.z.array(import_zod9.z.lazy(() => CABSection)), import_zod9.z.strictObject({}).transform(() => [])]).default(() => [
+    divider: import_zod10.z.boolean().optional(),
+    sections: import_zod10.z.union([import_zod10.z.array(import_zod10.z.lazy(() => CABSection)), import_zod10.z.strictObject({}).transform(() => [])]).default(() => [
       CABBannerSection.parse({
         buttonField: "undoAddToOrder",
         color: "success",
@@ -1104,77 +1117,77 @@ var CABOffersSection = import_zod9.z.lazy(
       CABDataSourceSection.parse({}),
       CABProductsSection.parse({})
     ]),
-    sectionType: import_zod9.z.literal(SectionType.offers).default(SectionType.offers)
+    sectionType: import_zod10.z.literal(SectionType.offers).default(SectionType.offers)
   })
 );
 
 // src/schema/widgets/checkout-and-beyond/carousel.ts
-var CABCarouselSection = import_zod10.z.lazy(
+var CABCarouselSection = import_zod11.z.lazy(
   () => CABLayoutSection.omit({ sections: true, sectionType: true }).extend({
-    autoAdvanceInterval: import_zod10.z.number().default(0),
-    itemsAtOnce: import_zod10.z.number().min(1).default(1),
+    autoAdvanceInterval: import_zod11.z.number().default(0),
+    itemsAtOnce: import_zod11.z.number().min(1).default(1),
     /** Card arrangement for the offers child (`horizontal` = side-by-side) — NOT the carousel's own `direction`. */
-    offersDirection: import_zod10.z.enum(offersDirections).default("vertical"),
-    sections: import_zod10.z.union([import_zod10.z.array(import_zod10.z.lazy(() => CABSection)), import_zod10.z.strictObject({}).transform(() => [])]).default(() => [CABOffersSection.parse({})]),
-    sectionType: import_zod10.z.literal(SectionType.carousel).default(SectionType.carousel)
+    offersDirection: import_zod11.z.enum(offersDirections).default("vertical"),
+    sections: import_zod11.z.union([import_zod11.z.array(import_zod11.z.lazy(() => CABSection)), import_zod11.z.strictObject({}).transform(() => [])]).default(() => [CABOffersSection.parse({})]),
+    sectionType: import_zod11.z.literal(SectionType.carousel).default(SectionType.carousel)
   })
 );
 
 // src/schema/widgets/checkout-and-beyond/cartLine.ts
-var import_zod11 = require("zod");
-var CABCartLineSection = import_zod11.z.lazy(
+var import_zod12 = require("zod");
+var CABCartLineSection = import_zod12.z.lazy(
   () => CABLayoutSection.omit({ sections: true, sectionType: true }).extend({
-    sections: import_zod11.z.union([import_zod11.z.array(import_zod11.z.lazy(() => CABSection)), import_zod11.z.strictObject({}).transform(() => [])]).default(() => [CABButtonSection.parse({ action: ButtonAction.switchToSubscription })]),
-    sectionType: import_zod11.z.literal(SectionType.cartLine).default(SectionType.cartLine)
+    sections: import_zod12.z.union([import_zod12.z.array(import_zod12.z.lazy(() => CABSection)), import_zod12.z.strictObject({}).transform(() => [])]).default(() => [CABButtonSection.parse({ action: ButtonAction.switchToSubscription })]),
+    sectionType: import_zod12.z.literal(SectionType.cartLine).default(SectionType.cartLine)
   })
 );
 
 // src/schema/widgets/checkout-and-beyond/discount.ts
 var import_uuid7 = require("uuid");
-var import_zod12 = require("zod");
-var CABDiscountSection = import_zod12.z.object({
+var import_zod13 = require("zod");
+var CABDiscountSection = import_zod13.z.object({
   ...CABVariableFields,
-  amount: import_zod12.z.union([import_zod12.z.number(), import_zod12.z.string()]).catch(0),
-  discountedBy: import_zod12.z.string().optional(),
-  discountedFrom: import_zod12.z.enum(discountSources).optional().catch(void 0),
-  message: import_zod12.z.string().optional(),
-  name: import_zod12.z.string().optional(),
-  quantity: import_zod12.z.number().default(1),
-  sectionId: import_zod12.z.uuid().default(() => (0, import_uuid7.v7)()),
-  sectionType: import_zod12.z.literal(SectionType.discount).default(SectionType.discount),
-  type: import_zod12.z.enum(discountTypes).catch("none")
+  amount: import_zod13.z.union([import_zod13.z.number(), import_zod13.z.string()]).catch(0),
+  discountedBy: import_zod13.z.string().optional(),
+  discountedFrom: import_zod13.z.enum(discountSources).optional().catch(void 0),
+  message: import_zod13.z.string().optional(),
+  name: import_zod13.z.string().optional(),
+  quantity: import_zod13.z.number().default(1),
+  sectionId: import_zod13.z.uuid().default(() => (0, import_uuid7.v7)()),
+  sectionType: import_zod13.z.literal(SectionType.discount).default(SectionType.discount),
+  type: import_zod13.z.enum(discountTypes).catch("none")
 });
 
 // src/schema/widgets/checkout-and-beyond/monetize.ts
 var import_uuid8 = require("uuid");
-var import_zod13 = require("zod");
-var CABMonetizeAds = import_zod13.z.object({
-  requestId: import_zod13.z.string().optional(),
+var import_zod14 = require("zod");
+var CABMonetizeAds = import_zod14.z.object({
+  requestId: import_zod14.z.string().optional(),
   /** Defaulted here, never in the beacon: absence of information is `ads` itself being absent. */
-  testing: import_zod13.z.boolean().default(false)
+  testing: import_zod14.z.boolean().default(false)
 });
-var CABMonetizeSection = import_zod13.z.object({
+var CABMonetizeSection = import_zod14.z.object({
   ...CABVariableFields,
   ads: CABMonetizeAds.optional(),
-  name: import_zod13.z.string().optional(),
+  name: import_zod14.z.string().optional(),
   /**
    * Server-hydrated offer cards (inline hydration): when `/cab/sections` was asked with a `monetize`
    * context block, the composed cards ride the marker itself — `[]` means "hydrated, no fill" (render
    * nothing, skip the fetch); ABSENT means "not hydrated" (the client fetches via `/cab/monetize`).
    */
-  offers: import_zod13.z.array(import_zod13.z.lazy(() => CABSection)).optional(),
+  offers: import_zod14.z.array(import_zod14.z.lazy(() => CABSection)).optional(),
   /** Privacy Policy footer href (the widget's `privacy_policy_url` setting); read server-side for hydration, relayed by the client only on the legacy `/cab/monetize` fallback. */
-  privacyPolicyUrl: import_zod13.z.string().optional(),
-  sectionId: import_zod13.z.uuid().default(() => (0, import_uuid8.v7)()),
-  sectionType: import_zod13.z.literal(SectionType.monetize).default(SectionType.monetize),
+  privacyPolicyUrl: import_zod14.z.string().optional(),
+  sectionId: import_zod14.z.uuid().default(() => (0, import_uuid8.v7)()),
+  sectionType: import_zod14.z.literal(SectionType.monetize).default(SectionType.monetize),
   /** Ads-taxonomy sub-vertical id (the widget's `sub_vertical` setting); paired with `vertical`. */
-  subVertical: import_zod13.z.string().optional(),
+  subVertical: import_zod14.z.string().optional(),
   /** Ads-taxonomy vertical id (the widget's `vertical` setting) — with `subVertical`, the admin Monetize editor's two configurables. */
-  vertical: import_zod13.z.string().optional()
+  vertical: import_zod14.z.string().optional()
 });
 
 // src/schema/widgets/checkout-and-beyond/progressBar.ts
-var import_zod14 = require("zod");
+var import_zod15 = require("zod");
 
 // src/schema/widgets/checkout-and-beyond/giftLabels.ts
 var GIFT_LABELS = {
@@ -1293,34 +1306,34 @@ var GIFT_LABELS = {
 };
 
 // src/schema/widgets/checkout-and-beyond/progressBar.ts
-var CABProgressTierExclusion = import_zod14.z.object({
-  collectionIds: import_zod14.z.array(import_zod14.z.number().int().positive()).default(() => []),
-  productIds: import_zod14.z.array(import_zod14.z.number().int().positive()).default(() => []),
-  tags: import_zod14.z.array(import_zod14.z.string().min(1)).default(() => []),
-  type: import_zod14.z.enum(progressTierExclusionTypes)
+var CABProgressTierExclusion = import_zod15.z.object({
+  collectionIds: import_zod15.z.array(import_zod15.z.number().int().positive()).default(() => []),
+  productIds: import_zod15.z.array(import_zod15.z.number().int().positive()).default(() => []),
+  tags: import_zod15.z.array(import_zod15.z.string().min(1)).default(() => []),
+  type: import_zod15.z.enum(progressTierExclusionTypes)
 });
-var CABProgressTier = import_zod14.z.object({
+var CABProgressTier = import_zod15.z.object({
   /**
    * Order-discount tiers only (onsite `discount`): the reward the order-discount Function applies at
    * cart time, carried so the client can resolve the `{{discountAmount}}` token in this tier's copy.
    * `fixedAmount`: shop-currency CENTS (FX-scaled by the client, like {@link CABProgressTier.threshold});
    * `percentage`: the whole-percent number rendered raw (`{n}%`). Absent on non-discount tiers.
    */
-  discount: import_zod14.z.object({ amount: import_zod14.z.number().nonnegative(), type: import_zod14.z.enum(["fixedAmount", "percentage"]) }).optional(),
+  discount: import_zod15.z.object({ amount: import_zod15.z.number().nonnegative(), type: import_zod15.z.enum(["fixedAmount", "percentage"]) }).optional(),
   /**
    * Per-tier exclusion rules (onsite `exclusions` when `exclusions_enabled`): lines they match don't count
    * toward this tier. Empty (the default, and the converter's output for a disabled or ruleless tier) means
    * the tier measures the plain bar-level adjusted progress. Consumers read ONLY the list named by the rule's
    * `type` — the converter leaves the other two at `[]`, so a populated off-type list never reaches the tree.
    */
-  exclusions: import_zod14.z.array(CABProgressTierExclusion).default(() => []),
+  exclusions: import_zod15.z.array(CABProgressTierExclusion).default(() => []),
   /**
    * Smart-cart product (gift) tiers only (onsite `filter_oos_variants`): when set, the client drops this
    * tier entirely once its gift has NO in-stock eligible variant — the milestone, fill slot and gift
    * controls all disappear, mirroring onsite removing the tier from `bar.tiers` before it renders. Absent
    * on shipping/discount/decorative tiers and left off by default (the tier renders regardless of stock).
    */
-  filterOosVariants: import_zod14.z.boolean().default(false),
+  filterOosVariants: import_zod15.z.boolean().default(false),
   /**
    * Smart-cart product (gift) tiers only: the reward unlocked at this tier. The client enriches
    * `productId`/`variantIds` to live variants (availability, price) and adds the chosen one to the cart
@@ -1328,10 +1341,10 @@ var CABProgressTier = import_zod14.z.object({
    * tiers and on tiers with no configured product. Cart add/remove is a later stage; carried here so the
    * tree is complete.
    */
-  gift: import_zod14.z.object({
-    productId: import_zod14.z.number().int().positive(),
-    title: import_zod14.z.string().optional(),
-    variantIds: import_zod14.z.array(import_zod14.z.number().int().positive()).default(() => [])
+  gift: import_zod15.z.object({
+    productId: import_zod15.z.number().int().positive(),
+    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
@@ -1351,7 +1364,7 @@ var CABProgressTier = import_zod14.z.object({
    * 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),
+  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
@@ -1361,35 +1374,35 @@ var CABProgressTier = import_zod14.z.object({
    * turns a blank label into an absent key, and a client-authored blank means the same thing — the renderer
    * emits no caption slot rather than an empty one). Plain text — a compact icon+label.
    */
-  label: import_zod14.z.record(import_zod14.z.string(), import_zod14.z.string()).optional(),
+  label: import_zod15.z.record(import_zod15.z.string(), import_zod15.z.string()).optional(),
   /**
    * Smart-cart product (gift) tiers only (onsite `product_tier_image`): show the gift's product image in
    * the step-row slot instead of the generic bag icon. The converter can't supply the image URL (config
    * carries only product IDs), so the client resolves it (authoritative Shopify featured image, React
    * parity) and falls back to the bag icon when the flag is off or no image resolves. Default false.
    */
-  productTierImage: import_zod14.z.boolean().default(false),
+  productTierImage: import_zod15.z.boolean().default(false),
   /**
    * The tier's goal, measured per `unit`. `currency` (default): SHOP-currency cents — the canonical
    * fallback: when the buyer's presentment currency has no entry in `thresholds`, the client
    * multiplies this by the live FX rate (converter maps the v1 `unlock_price`, e.g. `75` → `7500`).
    * `item`: a raw item count — no cents, no FX, no `thresholds` overrides.
    */
-  threshold: import_zod14.z.number().int().nonnegative(),
+  threshold: import_zod15.z.number().int().nonnegative(),
   /**
    * Per-presentment-currency goal overrides — lowercased ISO currency code → cents (e.g. `{ cad: 9900 }`).
    * When the buyer's currency has an entry, the client uses it verbatim INSTEAD of FX-converting
    * `threshold`, so merchants show intentional, clean per-market amounts (Shopify Markets) rather than a
    * converted base. Defaults to `{}` — no overrides means always fall back to `threshold`.
    */
-  thresholds: import_zod14.z.record(import_zod14.z.string(), import_zod14.z.number().int().nonnegative()).default(() => ({})),
+  thresholds: import_zod15.z.record(import_zod15.z.string(), import_zod15.z.number().int().nonnegative()).default(() => ({})),
   /**
    * Smart-cart tier identifier, mirrored onto the gift cart line's `_tier` attribute so the client can
    * match an in-cart gift back to its tier (add on reach, remove on downgrade/decline). Absent on the
    * shipping bar (single unlabeled tier, no gift).
    */
-  tierId: import_zod14.z.string().optional(),
-  tierType: import_zod14.z.enum(progressTierTypes).default(ProgressTierType.shipping),
+  tierId: import_zod15.z.string().optional(),
+  tierType: import_zod15.z.enum(progressTierTypes).default(ProgressTierType.shipping),
   /**
    * What this tier's progress is measured in — PER TIER (onsite's `unlock_condition_type` model, NOT
    * the React port's bar-level `tiers[0]` shortcut). `currency` compares money cents against the
@@ -1400,9 +1413,9 @@ var CABProgressTier = import_zod14.z.object({
    * count carries no injected noun (no English `item`/`items` inflection on localized copy); merchant
    * template text supplies grammatically-neutral wording around the token.
    */
-  unit: import_zod14.z.enum(progressTierUnits).default(ProgressTierUnit.currency)
+  unit: import_zod15.z.enum(progressTierUnits).default(ProgressTierUnit.currency)
 });
-var CABProgressBarSection = import_zod14.z.lazy(
+var CABProgressBarSection = import_zod15.z.lazy(
   () => CABLayoutSection.omit({ sectionType: true }).extend({
     /**
      * The onsite bar id (smart-cart TPB bars only). The client mirrors it to the cart's `_barId` attribute
@@ -1411,35 +1424,35 @@ var CABProgressBarSection = import_zod14.z.lazy(
      * checkout reaches the extension without it, so the client writes it or the tier gift's 100% discount
      * (and any tier order discount) never applies. Absent on the v1 shipping bar (no gift tiers, no id).
      */
-    barId: import_zod14.z.string().optional(),
+    barId: import_zod15.z.string().optional(),
     /** Empty = shown everywhere; otherwise uppercase ISO country codes. */
-    countryCodes: import_zod14.z.array(import_zod14.z.string().transform((code) => code.trim().toUpperCase())).default(() => []),
+    countryCodes: import_zod15.z.array(import_zod15.z.string().transform((code) => code.trim().toUpperCase())).default(() => []),
     /**
      * Uppercase ISO codes where a higher-precedence geo bar applies, so this (default, non-geo) bar is
      * hidden there — replicates React `getbar`'s geo-match-over-default precedence. Empty = never excluded.
      */
-    excludeCountryCodes: import_zod14.z.array(import_zod14.z.string().transform((code) => code.trim().toUpperCase())).default(() => []),
+    excludeCountryCodes: import_zod15.z.array(import_zod15.z.string().transform((code) => code.trim().toUpperCase())).default(() => []),
     /**
      * Measure progress against the PRE-discount subtotal (onsite `exclude_discount_in_subtotal`, and
      * forced on for bars with a discount tier so its own reward can't un-reach the tier). The client
      * adds the cart's discount allocations back to the live subtotal.
      */
-    excludeDiscountInSubtotal: import_zod14.z.boolean().default(false),
+    excludeDiscountInSubtotal: import_zod15.z.boolean().default(false),
     /** Variant ids the client subtracts from the adjusted subtotal (React `bar.excluded_products`). */
-    excludedVariantIds: import_zod14.z.array(import_zod14.z.number().int().positive()).default(() => []),
+    excludedVariantIds: import_zod15.z.array(import_zod15.z.number().int().positive()).default(() => []),
     /**
      * When the cart holds a subscription item, treat the bar as reached regardless of subtotal (React
      * `free_shipping_on_subscription(s)`). `freeShippingOnAll` is already a zero-threshold tier instead.
      */
-    freeShippingOnSubscription: import_zod14.z.boolean().default(false),
+    freeShippingOnSubscription: import_zod15.z.boolean().default(false),
     /** Localized heading over the gift controls (onsite `gift_area_title`, default 'FREE GIFTS'). */
-    giftAreaTitle: import_zod14.z.record(import_zod14.z.string(), import_zod14.z.string()).default(() => ({ en: "FREE GIFTS" })),
+    giftAreaTitle: import_zod15.z.record(import_zod15.z.string(), import_zod15.z.string()).default(() => ({ en: "FREE GIFTS" })),
     /** Localized gift-control labels (add/remove/heading); a tier's gift `title` beats `yourGift`. */
-    giftLabels: import_zod14.z.object({
-      addGift: import_zod14.z.record(import_zod14.z.string(), import_zod14.z.string()).default(() => ({ ...GIFT_LABELS.addGift })),
-      remove: import_zod14.z.record(import_zod14.z.string(), import_zod14.z.string()).default(() => ({ ...GIFT_LABELS.remove })),
-      selectOptions: import_zod14.z.record(import_zod14.z.string(), import_zod14.z.string()).default(() => ({ ...GIFT_LABELS.selectOptions })),
-      yourGift: import_zod14.z.record(import_zod14.z.string(), import_zod14.z.string()).default(() => ({ ...GIFT_LABELS.yourGift }))
+    giftLabels: import_zod15.z.object({
+      addGift: import_zod15.z.record(import_zod15.z.string(), import_zod15.z.string()).default(() => ({ ...GIFT_LABELS.addGift })),
+      remove: import_zod15.z.record(import_zod15.z.string(), import_zod15.z.string()).default(() => ({ ...GIFT_LABELS.remove })),
+      selectOptions: import_zod15.z.record(import_zod15.z.string(), import_zod15.z.string()).default(() => ({ ...GIFT_LABELS.selectOptions })),
+      yourGift: import_zod15.z.record(import_zod15.z.string(), import_zod15.z.string()).default(() => ({ ...GIFT_LABELS.yourGift }))
     }).default(() => ({
       addGift: { ...GIFT_LABELS.addGift },
       remove: { ...GIFT_LABELS.remove },
@@ -1447,38 +1460,38 @@ var CABProgressBarSection = import_zod14.z.lazy(
       yourGift: { ...GIFT_LABELS.yourGift }
     })),
     /** The bar's a11y label; the merchant names it in the editor, else this default (React parity). */
-    name: import_zod14.z.string().default("Order progress"),
+    name: import_zod15.z.string().default("Order progress"),
     /**
      * Bar fill color. An explicit (widget-authored) value is used verbatim; when absent the server
      * fills it with the live shop theme's `buttonBackground` (React `useRebuyTheme` parity). Still
      * absent after that ⇒ the theme fetch failed and the client renders its platform-default bar —
      * optional, not defaulted, so "merchant chose no color" stays distinguishable from any real value.
      */
-    progressColor: import_zod14.z.string().optional(),
-    sectionType: import_zod14.z.literal(SectionType.progressBar).default(SectionType.progressBar),
+    progressColor: import_zod15.z.string().optional(),
+    sectionType: import_zod15.z.literal(SectionType.progressBar).default(SectionType.progressBar),
     /**
      * The bar's milestones in the merchant's CONFIGURED order — the renderer does NOT sort them (022
      * O-B2: sorting by resolved threshold reversed configured milestones on out-of-order or mixed-unit
      * count-vs-cents bars). Drives the fill (even slot per tier) and, for smart-cart product tiers, the
      * gift add/remove. The visual tier display lives in `sections` (composable), NOT here.
      */
-    tiers: import_zod14.z.union([import_zod14.z.array(CABProgressTier), import_zod14.z.strictObject({}).transform(() => [])]).default(() => [])
+    tiers: import_zod15.z.union([import_zod15.z.array(CABProgressTier), import_zod15.z.strictObject({}).transform(() => [])]).default(() => [])
   })
 );
 
 // src/schema/widgets/checkout-and-beyond/quantity.ts
 var import_uuid9 = require("uuid");
-var import_zod15 = require("zod");
-var CABQuantitySection = import_zod15.z.object({
+var import_zod16 = require("zod");
+var CABQuantitySection = import_zod16.z.object({
   ...CABVariableFields,
-  errorMessages: import_zod15.z.record(
-    import_zod15.z.string(),
-    import_zod15.z.object({
+  errorMessages: import_zod16.z.record(
+    import_zod16.z.string(),
+    import_zod16.z.object({
       /** `{{step}}` is interpolated at render — the off-increment message React never gave a merchant key. */
-      increment: import_zod15.z.string().optional(),
-      max: import_zod15.z.string().optional(),
-      min: import_zod15.z.string().optional(),
-      neg: import_zod15.z.string().optional()
+      increment: import_zod16.z.string().optional(),
+      max: import_zod16.z.string().optional(),
+      min: import_zod16.z.string().optional(),
+      neg: import_zod16.z.string().optional()
     })
   ).default({
     en: {
@@ -1488,18 +1501,18 @@ var CABQuantitySection = import_zod15.z.object({
       neg: "Quantity cannot be negative"
     }
   }),
-  inputType: import_zod15.z.enum(quantityInputs).default(QuantityInput.select),
-  max: import_zod15.z.number().min(1).max(100).default(10),
-  min: import_zod15.z.number().min(1).default(1),
+  inputType: import_zod16.z.enum(quantityInputs).default(QuantityInput.select),
+  max: import_zod16.z.number().min(1).max(100).default(10),
+  min: import_zod16.z.number().min(1).default(1),
   /** The a11y label for the quantity control; the merchant names it in the editor, else this default. */
-  name: import_zod15.z.string().default("Quantity"),
-  sectionId: import_zod15.z.uuid().default(() => (0, import_uuid9.v7)()),
-  sectionType: import_zod15.z.literal(SectionType.quantity).default(SectionType.quantity)
+  name: import_zod16.z.string().default("Quantity"),
+  sectionId: import_zod16.z.uuid().default(() => (0, import_uuid9.v7)()),
+  sectionType: import_zod16.z.literal(SectionType.quantity).default(SectionType.quantity)
 });
 
 // src/schema/widgets/checkout-and-beyond/reviews.ts
 var import_uuid10 = require("uuid");
-var import_zod16 = require("zod");
+var import_zod17 = require("zod");
 
 // src/schema/widgets/checkout-and-beyond/reviewLabels.ts
 var REVIEW_LABELS = {
@@ -1562,68 +1575,69 @@ var REVIEW_LABELS = {
 };
 
 // src/schema/widgets/checkout-and-beyond/reviews.ts
-var CABReviewsSection = import_zod16.z.object({
+var CABReviewsSection = import_zod17.z.object({
   ...CABVariableFields,
-  color: import_zod16.z.string().default("#fadb14"),
+  color: import_zod17.z.string().default("#fadb14"),
   /**
    * Localized review-count templates (`{{reviewCount}}`), one/other plural forms; the client picks the
    * form via `Intl.PluralRules`. Defaults here (schema-first) so every tree localizes without converter
    * or merchant work.
    */
-  countLabels: import_zod16.z.object({
-    one: import_zod16.z.record(import_zod16.z.string(), import_zod16.z.string()).default(() => ({ ...REVIEW_LABELS.one })),
-    other: import_zod16.z.record(import_zod16.z.string(), import_zod16.z.string()).default(() => ({ ...REVIEW_LABELS.other }))
+  countLabels: import_zod17.z.object({
+    one: import_zod17.z.record(import_zod17.z.string(), import_zod17.z.string()).default(() => ({ ...REVIEW_LABELS.one })),
+    other: import_zod17.z.record(import_zod17.z.string(), import_zod17.z.string()).default(() => ({ ...REVIEW_LABELS.other }))
   }).default(() => ({ one: { ...REVIEW_LABELS.one }, other: { ...REVIEW_LABELS.other } })),
-  name: import_zod16.z.string().optional(),
-  sectionId: import_zod16.z.uuid().default(() => (0, import_uuid10.v7)()),
-  sectionType: import_zod16.z.literal(SectionType.reviews).default(SectionType.reviews),
-  size: import_zod16.z.enum(reviewsSizes).default(ReviewsSize.default),
+  name: import_zod17.z.string().optional(),
+  sectionId: import_zod17.z.uuid().default(() => (0, import_uuid10.v7)()),
+  sectionType: import_zod17.z.literal(SectionType.reviews).default(SectionType.reviews),
+  size: import_zod17.z.enum(reviewsSizes).default(ReviewsSize.default),
   /**
    * Star outline color, interpolated into a style by the renderer, so it is hex-constrained like
    * `CABButtonSection.color`. The legacy source (`PostPurchaseSettings.styles.starStrokeColor`) is a free
    * string: its converter must validate and fall back to this default rather than let one odd value drop
    * the whole reviews section.
    */
-  strokeColor: import_zod16.z.string().regex(HEX_COLOR_REGEX).default("#fadb14"),
+  strokeColor: import_zod17.z.string().regex(HEX_COLOR_REGEX).default("#fadb14"),
   /** Star outline width in px; `0` draws no outline. The legacy `styles.strokeWidth` is a STRING ('1') — its converter coerces. */
-  strokeWidth: import_zod16.z.number().nonnegative().default(0)
+  strokeWidth: import_zod17.z.number().nonnegative().default(0)
 });
 
 // src/schema/widgets/checkout-and-beyond/separator.ts
 var import_uuid11 = require("uuid");
-var import_zod17 = require("zod");
-var CABSeparatorSection = import_zod17.z.object({
+var import_zod18 = require("zod");
+var CABSeparatorSection = import_zod18.z.object({
   ...CABVariableFields,
-  sectionId: import_zod17.z.uuid().default(() => (0, import_uuid11.v7)()),
-  sectionType: import_zod17.z.literal(SectionType.separator).default(SectionType.separator)
+  sectionId: import_zod18.z.uuid().default(() => (0, import_uuid11.v7)()),
+  sectionType: import_zod18.z.literal(SectionType.separator).default(SectionType.separator)
 });
 
 // src/schema/widgets/checkout-and-beyond/variants.ts
 var import_compat3 = require("es-toolkit/compat");
 var import_uuid12 = require("uuid");
-var import_zod18 = require("zod");
-var CABVariantsSection = import_zod18.z.object({
+var import_zod19 = require("zod");
+var CABVariantsSection = import_zod19.z.object({
   ...CABVariableFields,
-  hideOutOfStockVariants: import_zod18.z.boolean().default(false),
-  name: import_zod18.z.string().optional(),
-  sectionId: import_zod18.z.uuid().default(() => (0, import_uuid12.v7)()),
-  sectionType: import_zod18.z.literal(SectionType.variants).default(SectionType.variants),
-  selector: import_zod18.z.enum((0, import_compat3.slice)(variantSelectors, 0, 3)).default(VariantSelector.menu),
-  variantMode: import_zod18.z.enum(variantModes).default(VariantMode.multiple)
+  hideOutOfStockVariants: import_zod19.z.boolean().default(false),
+  name: import_zod19.z.string().optional(),
+  sectionId: import_zod19.z.uuid().default(() => (0, import_uuid12.v7)()),
+  sectionType: import_zod19.z.literal(SectionType.variants).default(SectionType.variants),
+  selector: import_zod19.z.enum((0, import_compat3.slice)(variantSelectors, 0, 3)).default(VariantSelector.menu),
+  /** `productGroup` is additive (REB-24817): a renderer without group support must render nothing for it. */
+  variantMode: import_zod19.z.enum(variantsModes).default(VariantsMode.multiple)
 });
 
 // src/schema/widgets/checkout-and-beyond/shared.ts
-var CABBorder = import_zod19.z.object({
-  radius: import_zod19.z.enum(borderRadii).default(BorderRadius.base),
-  style: import_zod19.z.enum(borderStyles).default(BorderStyle.none),
-  width: import_zod19.z.enum(borderWidths).default(BorderWidth.base)
+var CABBorder = import_zod20.z.object({
+  radius: import_zod20.z.enum(borderRadii).default(BorderRadius.base),
+  style: import_zod20.z.enum(borderStyles).default(BorderStyle.none),
+  width: import_zod20.z.enum(borderWidths).default(BorderWidth.base)
 }).default({
   radius: BorderRadius.base,
   style: BorderStyle.none,
   width: BorderWidth.base
 });
-var CABSection = import_zod19.z.lazy(
-  () => import_zod19.z.discriminatedUnion("sectionType", [
+var CABSection = import_zod20.z.lazy(
+  () => import_zod20.z.discriminatedUnion("sectionType", [
     CABBannerSection,
     CABButtonSection,
     CABCarouselSection,
@@ -1646,50 +1660,50 @@ var CABSection = import_zod19.z.lazy(
 );
 
 // src/schema/widgets/checkout-and-beyond/layout.ts
-var GridItem = import_zod20.z.union([import_zod20.z.literal("auto"), import_zod20.z.literal("fill"), import_zod20.z.string().regex(/^\d+%$/), import_zod20.z.number()]);
-var CABLayoutWrapping = import_zod20.z.object({
-  breakAt: import_zod20.z.number().positive(),
-  maxPerLine: import_zod20.z.number().int().positive()
+var GridItem = import_zod21.z.union([import_zod21.z.literal("auto"), import_zod21.z.literal("fill"), import_zod21.z.string().regex(/^\d+%$/), import_zod21.z.number()]);
+var CABLayoutWrapping = import_zod21.z.object({
+  breakAt: import_zod21.z.number().positive(),
+  maxPerLine: import_zod21.z.number().int().positive()
 });
-var CABLayoutSection = import_zod20.z.object({
+var CABLayoutSection = import_zod21.z.object({
   ...CABVariableFields,
-  alignment: import_zod20.z.object({
-    horizontal: import_zod20.z.enum(horizontalAlignments).default(HorizontalAlignment.start),
-    vertical: import_zod20.z.enum(verticalAlignments).default(VerticalAlignment.top)
+  alignment: import_zod21.z.object({
+    horizontal: import_zod21.z.enum(horizontalAlignments).default(HorizontalAlignment.start),
+    vertical: import_zod21.z.enum(verticalAlignments).default(VerticalAlignment.top)
   }).default({
     horizontal: HorizontalAlignment.start,
     vertical: VerticalAlignment.top
   }),
-  border: import_zod20.z.lazy(() => CABBorder),
-  buttonField: import_zod20.z.enum(buttonFields).optional(),
-  direction: import_zod20.z.enum(directions).default(Direction.rows),
+  border: import_zod21.z.lazy(() => CABBorder),
+  buttonField: import_zod21.z.enum(buttonFields).optional(),
+  direction: import_zod21.z.enum(directions).default(Direction.rows),
   /**
    * Platform chrome around the section, not a layout behavior: `callout` is a subdued box with block borders
    * (the legacy post-purchase callout banner), `offer-content` the post-purchase offer's own content card.
    */
-  frame: import_zod20.z.enum(layoutFrames).optional(),
-  grid: import_zod20.z.object({
-    columns: import_zod20.z.union([import_zod20.z.array(GridItem), import_zod20.z.undefined()]).default(() => ["auto"]),
-    rows: import_zod20.z.union([import_zod20.z.array(GridItem), import_zod20.z.undefined()]).default(() => ["auto"])
+  frame: import_zod21.z.enum(layoutFrames).optional(),
+  grid: import_zod21.z.object({
+    columns: import_zod21.z.union([import_zod21.z.array(GridItem), import_zod21.z.undefined()]).default(() => ["auto"]),
+    rows: import_zod21.z.union([import_zod21.z.array(GridItem), import_zod21.z.undefined()]).default(() => ["auto"])
   }).default({ columns: ["auto"], rows: ["auto"] }).optional(),
-  name: import_zod20.z.string().optional(),
-  padding: import_zod20.z.enum(spacings).default(Spacing.none),
-  sectionId: import_zod20.z.uuid().default(() => (0, import_uuid13.v7)()),
-  sections: import_zod20.z.union([import_zod20.z.array(import_zod20.z.lazy(() => CABSection)), import_zod20.z.strictObject({}).transform(() => [])]).default(() => []),
-  sectionType: import_zod20.z.literal(SectionType.layout).default(SectionType.layout),
-  spacing: import_zod20.z.enum(spacings).default(Spacing.base),
+  name: import_zod21.z.string().optional(),
+  padding: import_zod21.z.enum(spacings).default(Spacing.none),
+  sectionId: import_zod21.z.uuid().default(() => (0, import_uuid13.v7)()),
+  sections: import_zod21.z.union([import_zod21.z.array(import_zod21.z.lazy(() => CABSection)), import_zod21.z.strictObject({}).transform(() => [])]).default(() => []),
+  sectionType: import_zod21.z.literal(SectionType.layout).default(SectionType.layout),
+  spacing: import_zod21.z.enum(spacings).default(Spacing.base),
   /** Fire-and-forget impression pixel POSTed once when the section is shown (e.g. a Monetize offer view). */
-  viewUrl: import_zod20.z.string().optional(),
-  width: import_zod20.z.number().default(100),
+  viewUrl: import_zod21.z.string().optional(),
+  width: import_zod21.z.number().default(100),
   wrapping: CABLayoutWrapping.optional()
 });
 
 // src/schema/widgets/checkout-and-beyond/banner.ts
-var CABBannerSection = import_zod21.z.lazy(
+var CABBannerSection = import_zod22.z.lazy(
   () => CABLayoutSection.omit({ sectionType: true }).extend({
-    buttonField: import_zod21.z.enum(buttonFields).optional(),
-    color: import_zod21.z.enum(bannerColors).default("info"),
-    dismissible: import_zod21.z.boolean().default(true),
+    buttonField: import_zod22.z.enum(buttonFields).optional(),
+    color: import_zod22.z.enum(bannerColors).default("info"),
+    dismissible: import_zod22.z.boolean().default(true),
     /**
      * The `s-banner` heading — localized content (a buyer can see a merchant-composed banner). Absent OR
      * blank ⇒ no heading; the renderer emits no heading slot for `''` rather than an empty one.
@@ -1705,8 +1719,8 @@ var CABBannerSection = import_zod21.z.lazy(
      * not a 500. Nothing emits `heading` yet; the first converter that maps merchant banner copy into it
      * either strips first or teaches `normalizeTextContent` to strip this field.
      */
-    heading: import_zod21.z.record(import_zod21.z.string(), import_zod21.z.string().refine(checkForHTML, NO_HTML)).optional(),
-    sectionType: import_zod21.z.literal(SectionType.banner).default(SectionType.banner)
+    heading: import_zod22.z.record(import_zod22.z.string(), import_zod22.z.string().refine(checkForHTML, NO_HTML)).optional(),
+    sectionType: import_zod22.z.literal(SectionType.banner).default(SectionType.banner)
   })
 );
 
@@ -1943,7 +1957,7 @@ var OFFER_LABELS = {
 };
 
 // src/schema/widgets/checkout-and-beyond/root.ts
-var import_zod22 = require("zod");
+var import_zod23 = require("zod");
 
 // src/schema/widgets/checkout-and-beyond/uiLabels.ts
 var UI_LABELS = {
@@ -1963,8 +1977,8 @@ var UI_LABELS = {
 };
 
 // src/schema/widgets/checkout-and-beyond/root.ts
-var localized = (fallback) => import_zod22.z.record(import_zod22.z.string(), import_zod22.z.string()).default(() => ({ ...fallback })).transform((labels) => Object.keys(labels).length > 0 ? labels : { ...fallback });
-var CABUILabels = import_zod22.z.object({
+var localized = (fallback) => import_zod23.z.record(import_zod23.z.string(), import_zod23.z.string()).default(() => ({ ...fallback })).transform((labels) => Object.keys(labels).length > 0 ? labels : { ...fallback });
+var CABUILabels = import_zod23.z.object({
   currentPage: localized(UI_LABELS.currentPage),
   guest: localized(UI_LABELS.guest),
   loadingOptions: localized(UI_LABELS.loadingOptions),
@@ -1989,37 +2003,37 @@ var CABUILabels = import_zod22.z.object({
   subscriptionOptions: { ...UI_LABELS.subscriptionOptions },
   updating: { ...UI_LABELS.updating }
 }));
-var TargetArea = import_zod22.z.object({
-  fill: import_zod22.z.boolean().optional(),
-  flip: import_zod22.z.enum(["both", "horizontal", "vertical"]).optional(),
-  icon: import_zod22.z.string(),
-  label: import_zod22.z.string(),
-  width: import_zod22.z.string()
+var TargetArea = import_zod23.z.object({
+  fill: import_zod23.z.boolean().optional(),
+  flip: import_zod23.z.enum(["both", "horizontal", "vertical"]).optional(),
+  icon: import_zod23.z.string(),
+  label: import_zod23.z.string(),
+  width: import_zod23.z.string()
 }).default(targetAreas[EditorMode.checkoutExtension][1]);
-var CABTracking = import_zod22.z.object({
-  enableAttribution: import_zod22.z.boolean().nullish().transform((value) => value ?? true),
-  enableSource: import_zod22.z.boolean().nullish().transform((value) => value ?? true),
-  enableWidget: import_zod22.z.boolean().nullish().transform((value) => value ?? true)
+var CABTracking = import_zod23.z.object({
+  enableAttribution: import_zod23.z.boolean().nullish().transform((value) => value ?? true),
+  enableSource: import_zod23.z.boolean().nullish().transform((value) => value ?? true),
+  enableWidget: import_zod23.z.boolean().nullish().transform((value) => value ?? true)
 }).nullish().transform((value) => value ?? { enableAttribution: true, enableSource: true, enableWidget: true });
-var CABExperiment = import_zod22.z.object({
-  elementId: import_zod22.z.number(),
-  experimentId: import_zod22.z.number(),
-  experimentType: import_zod22.z.string(),
-  selectedId: import_zod22.z.number()
+var CABExperiment = import_zod23.z.object({
+  elementId: import_zod23.z.number(),
+  experimentId: import_zod23.z.number(),
+  experimentType: import_zod23.z.string(),
+  selectedId: import_zod23.z.number()
 });
 var CABRootSection = CABLayoutSection.extend({
-  editorMode: import_zod22.z.enum(editorModes).default(EditorMode.checkoutExtension),
+  editorMode: import_zod23.z.enum(editorModes).default(EditorMode.checkoutExtension),
   experiment: CABExperiment.optional(),
   // Same rule as CABTracking above: the v1 converters pass raw legacy `previewMode` through, so a
   // `null` must fall back rather than throw the widget; malformed values still throw.
-  previewMode: import_zod22.z.boolean().nullish().transform((value) => value ?? false),
-  storeId: import_zod22.z.number().nullable().default(null),
+  previewMode: import_zod23.z.boolean().nullish().transform((value) => value ?? false),
+  storeId: import_zod23.z.number().nullable().default(null),
   targetArea: TargetArea.nullable(),
   tracking: CABTracking,
-  type: import_zod22.z.enum(widgetTypes).default(WidgetType.ui_extension_content_block),
+  type: import_zod23.z.enum(widgetTypes).default(WidgetType.ui_extension_content_block),
   uiLabels: CABUILabels,
-  version: import_zod22.z.literal(2).default(2),
-  widgetId: import_zod22.z.number().nullable().default(null)
+  version: import_zod23.z.literal(2).default(2),
+  widgetId: import_zod23.z.number().nullable().default(null)
 });
 
 // src/schema/widgets/checkout-and-beyond/switchLabels.ts