@rebuy/rebuy 3.41.0 → 3.43.0

package/dist/server/index.cjs

@@ -70,7 +70,7 @@ __export(server_exports, {
 module.exports = __toCommonJS(server_exports);
 
 // src/server/dataSourceResults.ts
-var import_es_toolkit6 = require("es-toolkit");
+var import_es_toolkit7 = require("es-toolkit");
 
 // src/gwp/getValidGwpProductIds.ts
 var getValidGwpProductIds = (matchedRules = []) => new Set(
@@ -695,7 +695,7 @@ var CabUserConfig = import_zod6.z.object({
 
 // src/schema/widgets/checkout-and-beyond/image.ts
 var import_uuid13 = require("uuid");
-var import_zod27 = require("zod");
+var import_zod28 = require("zod");
 
 // src/schema/widgets/checkout-and-beyond/common.ts
 var freezeEnum = (values2) => Object.freeze(Object.fromEntries(values2.map((v) => [v, v])));
@@ -865,6 +865,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"];
@@ -981,6 +983,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_zod7 = require("zod");
+var CABImageThumbnails = import_zod7.z.object({
+  limit: import_zod7.z.number().int().min(1).default(8),
+  perLine: import_zod7.z.number().int().min(1).max(8).default(4)
+});
+
 // src/schema/widgets/checkout-and-beyond/regex.ts
 var DYNAMIC_TOKEN_REGEX = /^\{\{\s*[A-Za-z]+\s*\}\}$/;
 var HEX_COLOR_REGEX = /^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/;
@@ -988,20 +997,20 @@ var ROOT_RELATIVE_PATH_REGEX = /^\/(?!\/)/;
 var HTML_TAGS_REGEX = /<\/?[a-zA-Z][^>]*>/g;
 
 // src/schema/widgets/checkout-and-beyond/shared.ts
-var import_zod26 = require("zod");
+var import_zod27 = require("zod");
 
 // src/schema/widgets/checkout-and-beyond/banner.ts
-var import_zod10 = require("zod");
+var import_zod11 = require("zod");
 
 // src/schema/widgets/checkout-and-beyond/layout.ts
 var import_uuid = require("uuid");
-var import_zod9 = require("zod");
+var import_zod10 = require("zod");
 
 // src/schema/widgets/checkout-and-beyond/variables.ts
-var import_zod8 = require("zod");
+var import_zod9 = require("zod");
 
 // src/schema/widgets/checkout-and-beyond/rule.ts
-var import_zod7 = require("zod");
+var import_zod8 = require("zod");
 var ruleTypes = [
   "cart",
   "cart_count",
@@ -1020,7 +1029,7 @@ var ruleTypes = [
   "product_type",
   "product_vendor"
 ];
-var ruleType = import_zod7.z.enum(ruleTypes);
+var ruleType = import_zod8.z.enum(ruleTypes);
 var RuleType = ruleType.enum;
 var ruleOperators = [
   "after",
@@ -1035,148 +1044,148 @@ var ruleOperators = [
   "greater_than",
   "less_than"
 ];
-var ruleOperator = import_zod7.z.enum(ruleOperators);
+var ruleOperator = import_zod8.z.enum(ruleOperators);
 var RuleOperator = ruleOperator.enum;
-var RuleCondition = import_zod7.z.object({
-  operator: import_zod7.z.enum(ruleOperators).default(RuleOperator.anything),
-  products: import_zod7.z.union([import_zod7.z.array(import_zod7.z.unknown()), import_zod7.z.strictObject({}).transform(() => [])]).default(() => []),
-  type: import_zod7.z.enum(ruleTypes).default(RuleType.cart_subtotal),
-  value: import_zod7.z.coerce.string().default("")
-});
-var RuleLogicBlock = import_zod7.z.object({
-  rules: import_zod7.z.array(RuleCondition).default(() => [])
-});
-var CABRulesetEntry = import_zod7.z.object({
-  exitIfMatched: import_zod7.z.boolean().default(true),
-  logic: import_zod7.z.array(RuleLogicBlock).default(() => []),
-  output: import_zod7.z.array(
-    import_zod7.z.object({
-      key: import_zod7.z.string().default("should_show"),
-      type: import_zod7.z.literal("data_json").default("data_json"),
-      value: import_zod7.z.string().default("true")
+var RuleCondition = import_zod8.z.object({
+  operator: import_zod8.z.enum(ruleOperators).default(RuleOperator.anything),
+  products: import_zod8.z.union([import_zod8.z.array(import_zod8.z.unknown()), import_zod8.z.strictObject({}).transform(() => [])]).default(() => []),
+  type: import_zod8.z.enum(ruleTypes).default(RuleType.cart_subtotal),
+  value: import_zod8.z.coerce.string().default("")
+});
+var RuleLogicBlock = import_zod8.z.object({
+  rules: import_zod8.z.array(RuleCondition).default(() => [])
+});
+var CABRulesetEntry = import_zod8.z.object({
+  exitIfMatched: import_zod8.z.boolean().default(true),
+  logic: import_zod8.z.array(RuleLogicBlock).default(() => []),
+  output: import_zod8.z.array(
+    import_zod8.z.object({
+      key: import_zod8.z.string().default("should_show"),
+      type: import_zod8.z.literal("data_json").default("data_json"),
+      value: import_zod8.z.string().default("true")
     })
   ).default(() => [{ key: "should_show", type: "data_json", value: "true" }])
 });
-var CABRuleset = import_zod7.z.union([import_zod7.z.array(CABRulesetEntry), import_zod7.z.strictObject({}).transform(() => [])]).default(() => []);
+var CABRuleset = import_zod8.z.union([import_zod8.z.array(CABRulesetEntry), import_zod8.z.strictObject({}).transform(() => [])]).default(() => []);
 
 // src/schema/widgets/checkout-and-beyond/variables.ts
-var variableEffect = import_zod8.z.enum(variableEffects);
-var CABVariableSeed = import_zod8.z.object({
-  dataSourceId: import_zod8.z.number().nullable().default(null),
+var variableEffect = import_zod9.z.enum(variableEffects);
+var CABVariableSeed = import_zod9.z.object({
+  dataSourceId: import_zod9.z.number().nullable().default(null),
   ruleset: CABRuleset
 });
-var CABBooleanVariable = import_zod8.z.object({
+var CABBooleanVariable = import_zod9.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_zod8.z.boolean().optional(),
-  name: import_zod8.z.string().min(1),
+  defaultValue: import_zod9.z.boolean().optional(),
+  name: import_zod9.z.string().min(1),
   seed: CABVariableSeed.optional(),
   /** Defaulted so every stored declaration (all boolean before `text` existed) parses unchanged. */
-  type: import_zod8.z.literal(VariableType.boolean).default(VariableType.boolean)
+  type: import_zod9.z.literal(VariableType.boolean).default(VariableType.boolean)
 });
-var CABTextVariable = import_zod8.z.object({
-  defaultValue: import_zod8.z.string(),
-  name: import_zod8.z.string().min(1),
-  seed: import_zod8.z.never().optional(),
-  type: import_zod8.z.literal(VariableType.text)
+var CABTextVariable = import_zod9.z.object({
+  defaultValue: import_zod9.z.string(),
+  name: import_zod9.z.string().min(1),
+  seed: import_zod9.z.never().optional(),
+  type: import_zod9.z.literal(VariableType.text)
 });
-var CABNumberVariable = import_zod8.z.object({
-  defaultValue: import_zod8.z.number(),
-  name: import_zod8.z.string().min(1),
-  seed: import_zod8.z.never().optional(),
-  type: import_zod8.z.literal(VariableType.number)
+var CABNumberVariable = import_zod9.z.object({
+  defaultValue: import_zod9.z.number(),
+  name: import_zod9.z.string().min(1),
+  seed: import_zod9.z.never().optional(),
+  type: import_zod9.z.literal(VariableType.number)
 });
-var CABVariable = import_zod8.z.union([CABTextVariable, CABNumberVariable, CABBooleanVariable]).transform(
+var CABVariable = import_zod9.z.union([CABTextVariable, CABNumberVariable, CABBooleanVariable]).transform(
   (variable) => variable.type === VariableType.boolean ? { ...variable, defaultValue: variable.defaultValue ?? variable.seed === void 0 } : variable
 );
-var CABVariableEffect = import_zod8.z.object({
+var CABVariableEffect = import_zod9.z.object({
   effect: variableEffect.default(VariableEffect.toggle),
-  variable: import_zod8.z.string().min(1)
+  variable: import_zod9.z.string().min(1)
 });
-var CABVisibility = import_zod8.z.object({
-  variable: import_zod8.z.string().min(1),
-  visibleWhen: import_zod8.z.boolean().default(true)
+var CABVisibility = import_zod9.z.object({
+  variable: import_zod9.z.string().min(1),
+  visibleWhen: import_zod9.z.boolean().default(true)
 });
-var contentOperator = import_zod8.z.enum(contentOperators);
-var resultCountOperator = import_zod8.z.enum(resultCountOperators);
-var resultTagOperator = import_zod8.z.enum(resultTagOperators);
-var mutatorEvent = import_zod8.z.enum(mutatorEvents);
-var CABContentTrigger = import_zod8.z.object({
+var contentOperator = import_zod9.z.enum(contentOperators);
+var resultCountOperator = import_zod9.z.enum(resultCountOperators);
+var resultTagOperator = import_zod9.z.enum(resultTagOperators);
+var mutatorEvent = import_zod9.z.enum(mutatorEvents);
+var CABContentTrigger = import_zod9.z.object({
   operator: contentOperator.default(ContentOperator.is_empty),
-  type: import_zod8.z.literal("content")
+  type: import_zod9.z.literal("content")
 });
-var CABResultCountTrigger = import_zod8.z.object({
+var CABResultCountTrigger = import_zod9.z.object({
   operator: resultCountOperator.default(ResultCountOperator.equals),
-  type: import_zod8.z.literal("result_count"),
-  value: import_zod8.z.number().default(0)
+  type: import_zod9.z.literal("result_count"),
+  value: import_zod9.z.number().default(0)
 });
-var CABResultTagTrigger = import_zod8.z.object({
+var CABResultTagTrigger = import_zod9.z.object({
   operator: resultTagOperator.default(ResultTagOperator.contains),
-  type: import_zod8.z.literal("result_tag"),
-  value: import_zod8.z.string().min(1)
+  type: import_zod9.z.literal("result_tag"),
+  value: import_zod9.z.string().min(1)
 });
-var CABEventTrigger = import_zod8.z.object({
+var CABEventTrigger = import_zod9.z.object({
   event: mutatorEvent,
-  type: import_zod8.z.literal("event")
+  type: import_zod9.z.literal("event")
 });
-var CABVariableTrigger = import_zod8.z.discriminatedUnion("type", [
+var CABVariableTrigger = import_zod9.z.discriminatedUnion("type", [
   CABContentTrigger,
   CABEventTrigger,
   CABResultCountTrigger,
   CABResultTagTrigger
 ]);
-var CABVariableMutator = import_zod8.z.object({
+var CABVariableMutator = import_zod9.z.object({
   effect: variableEffect.default(VariableEffect.set_false),
-  variable: import_zod8.z.string().min(1),
+  variable: import_zod9.z.string().min(1),
   when: CABVariableTrigger
 });
 var CABVariableFields = {
-  mutators: import_zod8.z.array(CABVariableMutator).optional(),
-  variables: import_zod8.z.array(CABVariable).refine((variables) => new Set(variables.map(({ name }) => name)).size === variables.length, {
+  mutators: import_zod9.z.array(CABVariableMutator).optional(),
+  variables: import_zod9.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/layout.ts
-var GridItem = import_zod9.z.union([import_zod9.z.literal("auto"), import_zod9.z.literal("fill"), import_zod9.z.string().regex(/^\d+%$/), import_zod9.z.number()]);
-var CABLayoutWrapping = import_zod9.z.object({
-  breakAt: import_zod9.z.number().positive(),
-  maxPerLine: import_zod9.z.number().int().positive()
+var GridItem = import_zod10.z.union([import_zod10.z.literal("auto"), import_zod10.z.literal("fill"), import_zod10.z.string().regex(/^\d+%$/), import_zod10.z.number()]);
+var CABLayoutWrapping = import_zod10.z.object({
+  breakAt: import_zod10.z.number().positive(),
+  maxPerLine: import_zod10.z.number().int().positive()
 });
-var CABLayoutSection = import_zod9.z.object({
+var CABLayoutSection = import_zod10.z.object({
   ...CABVariableFields,
-  alignment: import_zod9.z.object({
-    horizontal: import_zod9.z.enum(horizontalAlignments).default(HorizontalAlignment.start),
-    vertical: import_zod9.z.enum(verticalAlignments).default(VerticalAlignment.top)
+  alignment: import_zod10.z.object({
+    horizontal: import_zod10.z.enum(horizontalAlignments).default(HorizontalAlignment.start),
+    vertical: import_zod10.z.enum(verticalAlignments).default(VerticalAlignment.top)
   }).default({
     horizontal: HorizontalAlignment.start,
     vertical: VerticalAlignment.top
   }),
-  border: import_zod9.z.lazy(() => CABBorder),
-  buttonField: import_zod9.z.enum(buttonFields).optional(),
-  direction: import_zod9.z.enum(directions).default(Direction.rows),
+  border: import_zod10.z.lazy(() => CABBorder),
+  buttonField: import_zod10.z.enum(buttonFields).optional(),
+  direction: import_zod10.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_zod9.z.enum(layoutFrames).optional(),
-  grid: import_zod9.z.object({
-    columns: import_zod9.z.union([import_zod9.z.array(GridItem), import_zod9.z.undefined()]).default(() => ["auto"]),
-    rows: import_zod9.z.union([import_zod9.z.array(GridItem), import_zod9.z.undefined()]).default(() => ["auto"])
+  frame: import_zod10.z.enum(layoutFrames).optional(),
+  grid: import_zod10.z.object({
+    columns: import_zod10.z.union([import_zod10.z.array(GridItem), import_zod10.z.undefined()]).default(() => ["auto"]),
+    rows: import_zod10.z.union([import_zod10.z.array(GridItem), import_zod10.z.undefined()]).default(() => ["auto"])
   }).default({ columns: ["auto"], rows: ["auto"] }).optional(),
-  name: import_zod9.z.string().optional(),
-  padding: import_zod9.z.enum(spacings).default(Spacing.none),
-  sectionId: import_zod9.z.uuid().default(() => (0, import_uuid.v7)()),
-  sections: import_zod9.z.union([import_zod9.z.array(import_zod9.z.lazy(() => CABSection)), import_zod9.z.strictObject({}).transform(() => [])]).default(() => []),
-  sectionType: import_zod9.z.literal(SectionType.layout).default(SectionType.layout),
-  spacing: import_zod9.z.enum(spacings).default(Spacing.base),
+  name: import_zod10.z.string().optional(),
+  padding: import_zod10.z.enum(spacings).default(Spacing.none),
+  sectionId: import_zod10.z.uuid().default(() => (0, import_uuid.v7)()),
+  sections: import_zod10.z.union([import_zod10.z.array(import_zod10.z.lazy(() => CABSection)), import_zod10.z.strictObject({}).transform(() => [])]).default(() => []),
+  sectionType: import_zod10.z.literal(SectionType.layout).default(SectionType.layout),
+  spacing: import_zod10.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_zod9.z.string().optional(),
-  width: import_zod9.z.number().default(100),
+  viewUrl: import_zod10.z.string().optional(),
+  width: import_zod10.z.number().default(100),
   wrapping: CABLayoutWrapping.optional()
 });
 
@@ -1247,11 +1256,11 @@ var isTextType = isSectionType(SectionType.text);
 var isVariantsType = isSectionType(SectionType.variants);
 
 // src/schema/widgets/checkout-and-beyond/banner.ts
-var CABBannerSection = import_zod10.z.lazy(
+var CABBannerSection = import_zod11.z.lazy(
   () => CABLayoutSection.omit({ sectionType: true }).extend({
-    buttonField: import_zod10.z.enum(buttonFields).optional(),
-    color: import_zod10.z.enum(bannerColors).default("info"),
-    dismissible: import_zod10.z.boolean().default(true),
+    buttonField: import_zod11.z.enum(buttonFields).optional(),
+    color: import_zod11.z.enum(bannerColors).default("info"),
+    dismissible: import_zod11.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.
@@ -1267,83 +1276,83 @@ var CABBannerSection = import_zod10.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_zod10.z.record(import_zod10.z.string(), import_zod10.z.string().refine(checkForHTML, NO_HTML)).optional(),
-    sectionType: import_zod10.z.literal(SectionType.banner).default(SectionType.banner)
+    heading: import_zod11.z.record(import_zod11.z.string(), import_zod11.z.string().refine(checkForHTML, NO_HTML)).optional(),
+    sectionType: import_zod11.z.literal(SectionType.banner).default(SectionType.banner)
   })
 );
 
 // src/schema/widgets/checkout-and-beyond/button.ts
 var import_uuid3 = require("uuid");
-var import_zod12 = require("zod");
+var import_zod13 = require("zod");
 
 // src/schema/widgets/checkout-and-beyond/text.ts
 var import_compat2 = require("es-toolkit/compat");
 var import_uuid2 = require("uuid");
-var import_zod11 = require("zod");
-var enumOrOmit = (...vals) => import_zod11.z.string().transform((val) => vals.includes(val) ? val : void 0).optional();
-var TiptapText = import_zod11.z.object({
-  marks: import_zod11.z.union([
-    import_zod11.z.array(
-      import_zod11.z.discriminatedUnion("type", [
-        import_zod11.z.object({ type: import_zod11.z.literal("bold") }),
-        import_zod11.z.object({ type: import_zod11.z.literal("italic") }),
-        import_zod11.z.object({
-          attrs: import_zod11.z.object({
-            class: import_zod11.z.string().nullable(),
-            href: import_zod11.z.union([
-              import_zod11.z.url(),
-              import_zod11.z.literal("#"),
-              import_zod11.z.string().regex(DYNAMIC_TOKEN_REGEX),
-              import_zod11.z.string().regex(ROOT_RELATIVE_PATH_REGEX)
+var import_zod12 = require("zod");
+var enumOrOmit = (...vals) => import_zod12.z.string().transform((val) => vals.includes(val) ? val : void 0).optional();
+var TiptapText = import_zod12.z.object({
+  marks: import_zod12.z.union([
+    import_zod12.z.array(
+      import_zod12.z.discriminatedUnion("type", [
+        import_zod12.z.object({ type: import_zod12.z.literal("bold") }),
+        import_zod12.z.object({ type: import_zod12.z.literal("italic") }),
+        import_zod12.z.object({
+          attrs: import_zod12.z.object({
+            class: import_zod12.z.string().nullable(),
+            href: import_zod12.z.union([
+              import_zod12.z.url(),
+              import_zod12.z.literal("#"),
+              import_zod12.z.string().regex(DYNAMIC_TOKEN_REGEX),
+              import_zod12.z.string().regex(ROOT_RELATIVE_PATH_REGEX)
             ]),
-            rel: import_zod11.z.string().default("noopener noreferrer nofollow"),
-            target: import_zod11.z.string().default("_blank")
+            rel: import_zod12.z.string().default("noopener noreferrer nofollow"),
+            target: import_zod12.z.string().default("_blank")
           }),
-          type: import_zod11.z.literal("link")
+          type: import_zod12.z.literal("link")
         }),
-        import_zod11.z.object({ type: import_zod11.z.literal("strike") }),
-        import_zod11.z.object({
-          attrs: import_zod11.z.object({
+        import_zod12.z.object({ type: import_zod12.z.literal("strike") }),
+        import_zod12.z.object({
+          attrs: import_zod12.z.object({
             color: enumOrOmit(...textColorNames).default(TextColorName.base),
             fontSize: enumOrOmit(...textSizeNames).default(TextSizeName.base)
           }),
-          type: import_zod11.z.literal("textStyle")
+          type: import_zod12.z.literal("textStyle")
         })
       ])
     ),
-    import_zod11.z.strictObject({}).transform(() => [])
+    import_zod12.z.strictObject({}).transform(() => [])
   ]).optional(),
-  text: import_zod11.z.string().default(""),
-  type: import_zod11.z.literal("text").default("text")
+  text: import_zod12.z.string().default(""),
+  type: import_zod12.z.literal("text").default("text")
 });
-var TiptapParagraph = import_zod11.z.object({
-  attrs: import_zod11.z.object({
+var TiptapParagraph = import_zod12.z.object({
+  attrs: import_zod12.z.object({
     textAlign: enumOrOmit(...textAlignments)
   }).default({ textAlign: TextAlignment.start }),
-  content: import_zod11.z.union([import_zod11.z.array(TiptapText), import_zod11.z.strictObject({}).transform(() => [])]).default(() => []),
-  type: import_zod11.z.literal("paragraph").default("paragraph")
+  content: import_zod12.z.union([import_zod12.z.array(TiptapText), import_zod12.z.strictObject({}).transform(() => [])]).default(() => []),
+  type: import_zod12.z.literal("paragraph").default("paragraph")
 });
-var TiptapDocument = import_zod11.z.object({
-  attrs: import_zod11.z.object({
+var TiptapDocument = import_zod12.z.object({
+  attrs: import_zod12.z.object({
     blockSpacing: enumOrOmit(...spacings)
   }).default({ blockSpacing: Spacing.base }),
-  content: import_zod11.z.union([import_zod11.z.array(TiptapParagraph), import_zod11.z.strictObject({}).transform(() => [])]).default(() => [TiptapParagraph.parse({})]),
-  type: import_zod11.z.literal("doc").default("doc")
+  content: import_zod12.z.union([import_zod12.z.array(TiptapParagraph), import_zod12.z.strictObject({}).transform(() => [])]).default(() => [TiptapParagraph.parse({})]),
+  type: import_zod12.z.literal("doc").default("doc")
 });
-var CABTextTier = import_zod11.z.object({
-  threshold: import_zod11.z.number().int().nonnegative(),
-  thresholds: import_zod11.z.record(import_zod11.z.string(), import_zod11.z.number().int().nonnegative()).default(() => ({})),
-  tierId: import_zod11.z.string().optional(),
-  tierType: import_zod11.z.enum(progressTierTypes).default(ProgressTierType.shipping)
+var CABTextTier = import_zod12.z.object({
+  threshold: import_zod12.z.number().int().nonnegative(),
+  thresholds: import_zod12.z.record(import_zod12.z.string(), import_zod12.z.number().int().nonnegative()).default(() => ({})),
+  tierId: import_zod12.z.string().optional(),
+  tierType: import_zod12.z.enum(progressTierTypes).default(ProgressTierType.shipping)
 });
-var CABTextSection = import_zod11.z.object({
+var CABTextSection = import_zod12.z.object({
   ...CABVariableFields,
-  buttonField: import_zod11.z.enum(buttonFields).optional(),
-  content: import_zod11.z.record(import_zod11.z.string(), import_zod11.z.union([import_zod11.z.string(), TiptapDocument]).refine(checkForHTML, NO_HTML).optional()).default({ en: TiptapDocument.parse({}) }).optional(),
-  name: import_zod11.z.string().optional(),
-  optionId: import_zod11.z.number().optional(),
-  sectionId: import_zod11.z.uuid().default(() => (0, import_uuid2.v7)()),
-  sectionType: import_zod11.z.literal(SectionType.text).default(SectionType.text),
+  buttonField: import_zod12.z.enum(buttonFields).optional(),
+  content: import_zod12.z.record(import_zod12.z.string(), import_zod12.z.union([import_zod12.z.string(), TiptapDocument]).refine(checkForHTML, NO_HTML).optional()).default({ en: TiptapDocument.parse({}) }).optional(),
+  name: import_zod12.z.string().optional(),
+  optionId: import_zod12.z.number().optional(),
+  sectionId: import_zod12.z.uuid().default(() => (0, import_uuid2.v7)()),
+  sectionType: import_zod12.z.literal(SectionType.text).default(SectionType.text),
   tier: CABTextTier.optional()
 }).superRefine(({ buttonField, content }, ctx) => {
   if (buttonField === ButtonField.destinationUrl && content) {
@@ -1365,35 +1374,35 @@ var CABTextSection = import_zod11.z.object({
 });
 
 // src/schema/widgets/checkout-and-beyond/button.ts
-var CABButtonContent = import_zod12.z.lazy(
-  () => import_zod12.z.discriminatedUnion("sectionType", [CABImageSection, CABLayoutSection, CABTextSection])
+var CABButtonContent = import_zod13.z.lazy(
+  () => import_zod13.z.discriminatedUnion("sectionType", [CABImageSection, CABLayoutSection, CABTextSection])
 );
-var CABButtonSection = import_zod12.z.object({
+var CABButtonSection = import_zod13.z.object({
   ...CABVariableFields,
-  action: import_zod12.z.union([import_zod12.z.literal(""), import_zod12.z.enum(buttonActions)]).default(""),
-  buttonStyle: import_zod12.z.enum(buttonStyles).default(ButtonStyle.primary),
-  custom: import_zod12.z.object({
-    color: import_zod12.z.string().regex(HEX_COLOR_REGEX).default("#005bd3"),
-    height: import_zod12.z.number().default(52),
-    width: import_zod12.z.number().default(300)
+  action: import_zod13.z.union([import_zod13.z.literal(""), import_zod13.z.enum(buttonActions)]).default(""),
+  buttonStyle: import_zod13.z.enum(buttonStyles).default(ButtonStyle.primary),
+  custom: import_zod13.z.object({
+    color: import_zod13.z.string().regex(HEX_COLOR_REGEX).default("#005bd3"),
+    height: import_zod13.z.number().default(52),
+    width: import_zod13.z.number().default(300)
   }).default({
     color: "#005bd3",
     height: 52,
     width: 300
   }),
-  disableDowngrade: import_zod12.z.boolean().default(false),
-  name: import_zod12.z.string().optional(),
-  optionId: import_zod12.z.number().optional(),
-  popover: import_zod12.z.object({
-    alignment: import_zod12.z.enum(textAlignments).default(TextAlignment.center),
-    position: import_zod12.z.enum(popoverPositions).default(PopoverPosition.blockStart)
+  disableDowngrade: import_zod13.z.boolean().default(false),
+  name: import_zod13.z.string().optional(),
+  optionId: import_zod13.z.number().optional(),
+  popover: import_zod13.z.object({
+    alignment: import_zod13.z.enum(textAlignments).default(TextAlignment.center),
+    position: import_zod13.z.enum(popoverPositions).default(PopoverPosition.blockStart)
   }).optional().default(() => ({
     alignment: TextAlignment.center,
     position: PopoverPosition.blockStart
   })),
-  sectionId: import_zod12.z.uuid().default(() => (0, import_uuid3.v7)()),
-  sections: import_zod12.z.union([import_zod12.z.array(CABButtonContent), import_zod12.z.strictObject({}).transform(() => [])]).default(() => []),
-  sectionType: import_zod12.z.literal(SectionType.button).default(SectionType.button),
+  sectionId: import_zod13.z.uuid().default(() => (0, import_uuid3.v7)()),
+  sections: import_zod13.z.union([import_zod13.z.array(CABButtonContent), import_zod13.z.strictObject({}).transform(() => [])]).default(() => []),
+  sectionType: import_zod13.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
@@ -1408,25 +1417,25 @@ var CABButtonSection = import_zod12.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_zod12.z.object({ tierId: import_zod12.z.string().min(1) }).optional(),
+  tier: import_zod13.z.object({ tierId: import_zod13.z.string().min(1) }).optional(),
   /** Fire-and-forget pixel POSTed when the button is clicked (e.g. a Monetize decline). */
-  trackingUrl: import_zod12.z.string().optional(),
+  trackingUrl: import_zod13.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_zod12.z.array(CABVariableEffect).optional()
+  variableEffects: import_zod13.z.array(CABVariableEffect).optional()
 });
 
 // src/schema/widgets/checkout-and-beyond/carousel.ts
-var import_zod17 = require("zod");
+var import_zod18 = require("zod");
 
 // src/schema/widgets/checkout-and-beyond/offers.ts
-var import_zod16 = require("zod");
+var import_zod17 = require("zod");
 
 // src/schema/widgets/checkout-and-beyond/dataSource.ts
 var import_uuid4 = require("uuid");
-var import_zod13 = require("zod");
+var import_zod14 = require("zod");
 
 // src/schema/widgets/checkout-and-beyond/constants.ts
 var import_es_toolkit3 = require("es-toolkit");
@@ -1480,77 +1489,77 @@ var targetAreas = {
 };
 
 // src/schema/widgets/checkout-and-beyond/dataSource.ts
-var CABDiscount = import_zod13.z.object({
-  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),
-  type: import_zod13.z.enum(discountTypes).catch("none")
-});
-var CABIntegrations = import_zod13.z.object({
-  judgeme: import_zod13.z.boolean().default(false),
-  junip: import_zod13.z.boolean().default(false),
-  klaviyo: import_zod13.z.boolean().default(false),
-  loox: import_zod13.z.boolean().default(false),
-  okendo: import_zod13.z.boolean().default(false),
-  opinew: import_zod13.z.boolean().default(false),
-  reviewsio: import_zod13.z.boolean().default(false),
-  stamped: import_zod13.z.boolean().default(false),
-  yotpo: import_zod13.z.boolean().default(false)
-});
-var CABVariantLabels = import_zod13.z.object({
-  variantOption: import_zod13.z.string().optional().catch(void 0),
-  variantOptions: import_zod13.z.string().optional().catch(void 0)
-});
-var CABDataSourceSection = import_zod13.z.object({
-  dataSourceId: import_zod13.z.number().nullable().default(null),
-  dataSourcePath: import_zod13.z.string().default(DEFAULT_ENDPOINTS[0].value),
+var CABDiscount = import_zod14.z.object({
+  amount: import_zod14.z.union([import_zod14.z.number(), import_zod14.z.string()]).catch(0),
+  discountedBy: import_zod14.z.string().optional(),
+  discountedFrom: import_zod14.z.enum(discountSources).optional().catch(void 0),
+  type: import_zod14.z.enum(discountTypes).catch("none")
+});
+var CABIntegrations = import_zod14.z.object({
+  judgeme: import_zod14.z.boolean().default(false),
+  junip: import_zod14.z.boolean().default(false),
+  klaviyo: import_zod14.z.boolean().default(false),
+  loox: import_zod14.z.boolean().default(false),
+  okendo: import_zod14.z.boolean().default(false),
+  opinew: import_zod14.z.boolean().default(false),
+  reviewsio: import_zod14.z.boolean().default(false),
+  stamped: import_zod14.z.boolean().default(false),
+  yotpo: import_zod14.z.boolean().default(false)
+});
+var CABVariantLabels = import_zod14.z.object({
+  variantOption: import_zod14.z.string().optional().catch(void 0),
+  variantOptions: import_zod14.z.string().optional().catch(void 0)
+});
+var CABDataSourceSection = import_zod14.z.object({
+  dataSourceId: import_zod14.z.number().nullable().default(null),
+  dataSourcePath: import_zod14.z.string().default(DEFAULT_ENDPOINTS[0].value),
   discount: CABDiscount.optional(),
   integrations: CABIntegrations.optional(),
-  limit: import_zod13.z.number().default(1),
-  matchVariant: import_zod13.z.boolean().default(false),
-  matchVariantOutOfStock: import_zod13.z.boolean().default(false),
-  name: import_zod13.z.string().default(DEFAULT_ENDPOINTS[0].label),
-  productType: import_zod13.z.enum(productTypes).optional(),
-  sectionId: import_zod13.z.uuid().default(() => (0, import_uuid4.v7)()),
-  sectionType: import_zod13.z.literal(SectionType.dataSource).default(SectionType.dataSource),
+  limit: import_zod14.z.number().default(1),
+  matchVariant: import_zod14.z.boolean().default(false),
+  matchVariantOutOfStock: import_zod14.z.boolean().default(false),
+  name: import_zod14.z.string().default(DEFAULT_ENDPOINTS[0].label),
+  productType: import_zod14.z.enum(productTypes).optional(),
+  sectionId: import_zod14.z.uuid().default(() => (0, import_uuid4.v7)()),
+  sectionType: import_zod14.z.literal(SectionType.dataSource).default(SectionType.dataSource),
   /** Default subscribe-vs-one-time for `productType: both` (legacy `subscription_is_default`). */
-  subscriptionIsDefault: import_zod13.z.boolean().default(false),
-  treatAsGwp: import_zod13.z.boolean().default(false),
+  subscriptionIsDefault: import_zod14.z.boolean().default(false),
+  treatAsGwp: import_zod14.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_zod15 = require("zod");
+var import_zod16 = require("zod");
 
 // src/schema/widgets/checkout-and-beyond/product.ts
 var import_uuid5 = require("uuid");
-var import_zod14 = require("zod");
-var CABVariantContent = import_zod14.z.lazy(
-  () => import_zod14.z.discriminatedUnion("sectionType", [CABButtonSection, CABTextSection])
+var import_zod15 = require("zod");
+var CABVariantContent = import_zod15.z.lazy(
+  () => import_zod15.z.discriminatedUnion("sectionType", [CABButtonSection, CABTextSection])
 );
-var CABProductSection = import_zod14.z.object({
+var CABProductSection = import_zod15.z.object({
   ...CABVariableFields,
-  name: import_zod14.z.string().optional(),
-  productId: import_zod14.z.number().nullable().default(null),
-  sectionId: import_zod14.z.uuid().default(() => (0, import_uuid5.v7)()),
-  sections: import_zod14.z.union([import_zod14.z.array(CABVariantContent), import_zod14.z.strictObject({}).transform(() => [])]).default(() => []),
-  sectionType: import_zod14.z.literal(SectionType.product).default(SectionType.product),
-  selectors: import_zod14.z.record(import_zod14.z.string(), import_zod14.z.enum(variantSelectors).default(VariantSelector.menu)).default(() => ({})),
-  variantMode: import_zod14.z.enum(variantModes).default(VariantMode.multiple)
+  name: import_zod15.z.string().optional(),
+  productId: import_zod15.z.number().nullable().default(null),
+  sectionId: import_zod15.z.uuid().default(() => (0, import_uuid5.v7)()),
+  sections: import_zod15.z.union([import_zod15.z.array(CABVariantContent), import_zod15.z.strictObject({}).transform(() => [])]).default(() => []),
+  sectionType: import_zod15.z.literal(SectionType.product).default(SectionType.product),
+  selectors: import_zod15.z.record(import_zod15.z.string(), import_zod15.z.enum(variantSelectors).default(VariantSelector.menu)).default(() => ({})),
+  variantMode: import_zod15.z.enum(variantModes).default(VariantMode.multiple)
 });
 
 // src/schema/widgets/checkout-and-beyond/products.ts
-var CABProductsSection = import_zod15.z.object({
+var CABProductsSection = import_zod16.z.object({
   ...CABVariableFields,
-  name: import_zod15.z.string().optional(),
-  sectionId: import_zod15.z.uuid().default(() => (0, import_uuid6.v7)()),
-  sections: import_zod15.z.union([import_zod15.z.array(import_zod15.z.lazy(() => CABProductSection)), import_zod15.z.strictObject({}).transform(() => [])]).default(() => []),
-  sectionType: import_zod15.z.literal(SectionType.products).default(SectionType.products)
+  name: import_zod16.z.string().optional(),
+  sectionId: import_zod16.z.uuid().default(() => (0, import_uuid6.v7)()),
+  sections: import_zod16.z.union([import_zod16.z.array(import_zod16.z.lazy(() => CABProductSection)), import_zod16.z.strictObject({}).transform(() => [])]).default(() => []),
+  sectionType: import_zod16.z.literal(SectionType.products).default(SectionType.products)
 });
 
 // src/schema/widgets/checkout-and-beyond/offers.ts
-var CABOffersSection = import_zod16.z.lazy(
+var CABOffersSection = import_zod17.z.lazy(
   () => CABLayoutSection.omit({ sections: true, sectionType: true }).extend({
     /**
      * A rule between consecutive cards in the vertical list — legacy checkout-offers' `<Divider />`,
@@ -1558,8 +1567,8 @@ var CABOffersSection = import_zod16.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_zod16.z.boolean().optional(),
-    sections: import_zod16.z.union([import_zod16.z.array(import_zod16.z.lazy(() => CABSection)), import_zod16.z.strictObject({}).transform(() => [])]).default(() => [
+    divider: import_zod17.z.boolean().optional(),
+    sections: import_zod17.z.union([import_zod17.z.array(import_zod17.z.lazy(() => CABSection)), import_zod17.z.strictObject({}).transform(() => [])]).default(() => [
       CABBannerSection.parse({
         buttonField: "undoAddToOrder",
         color: "success",
@@ -1573,77 +1582,77 @@ var CABOffersSection = import_zod16.z.lazy(
       CABDataSourceSection.parse({}),
       CABProductsSection.parse({})
     ]),
-    sectionType: import_zod16.z.literal(SectionType.offers).default(SectionType.offers)
+    sectionType: import_zod17.z.literal(SectionType.offers).default(SectionType.offers)
   })
 );
 
 // src/schema/widgets/checkout-and-beyond/carousel.ts
-var CABCarouselSection = import_zod17.z.lazy(
+var CABCarouselSection = import_zod18.z.lazy(
   () => CABLayoutSection.omit({ sections: true, sectionType: true }).extend({
-    autoAdvanceInterval: import_zod17.z.number().default(0),
-    itemsAtOnce: import_zod17.z.number().min(1).default(1),
+    autoAdvanceInterval: import_zod18.z.number().default(0),
+    itemsAtOnce: import_zod18.z.number().min(1).default(1),
     /** Card arrangement for the offers child (`horizontal` = side-by-side) — NOT the carousel's own `direction`. */
-    offersDirection: import_zod17.z.enum(offersDirections).default("vertical"),
-    sections: import_zod17.z.union([import_zod17.z.array(import_zod17.z.lazy(() => CABSection)), import_zod17.z.strictObject({}).transform(() => [])]).default(() => [CABOffersSection.parse({})]),
-    sectionType: import_zod17.z.literal(SectionType.carousel).default(SectionType.carousel)
+    offersDirection: import_zod18.z.enum(offersDirections).default("vertical"),
+    sections: import_zod18.z.union([import_zod18.z.array(import_zod18.z.lazy(() => CABSection)), import_zod18.z.strictObject({}).transform(() => [])]).default(() => [CABOffersSection.parse({})]),
+    sectionType: import_zod18.z.literal(SectionType.carousel).default(SectionType.carousel)
   })
 );
 
 // src/schema/widgets/checkout-and-beyond/cartLine.ts
-var import_zod18 = require("zod");
-var CABCartLineSection = import_zod18.z.lazy(
+var import_zod19 = require("zod");
+var CABCartLineSection = import_zod19.z.lazy(
   () => CABLayoutSection.omit({ sections: true, sectionType: true }).extend({
-    sections: import_zod18.z.union([import_zod18.z.array(import_zod18.z.lazy(() => CABSection)), import_zod18.z.strictObject({}).transform(() => [])]).default(() => [CABButtonSection.parse({ action: ButtonAction.switchToSubscription })]),
-    sectionType: import_zod18.z.literal(SectionType.cartLine).default(SectionType.cartLine)
+    sections: import_zod19.z.union([import_zod19.z.array(import_zod19.z.lazy(() => CABSection)), import_zod19.z.strictObject({}).transform(() => [])]).default(() => [CABButtonSection.parse({ action: ButtonAction.switchToSubscription })]),
+    sectionType: import_zod19.z.literal(SectionType.cartLine).default(SectionType.cartLine)
   })
 );
 
 // src/schema/widgets/checkout-and-beyond/discount.ts
 var import_uuid7 = require("uuid");
-var import_zod19 = require("zod");
-var CABDiscountSection = import_zod19.z.object({
+var import_zod20 = require("zod");
+var CABDiscountSection = import_zod20.z.object({
   ...CABVariableFields,
-  amount: import_zod19.z.union([import_zod19.z.number(), import_zod19.z.string()]).catch(0),
-  discountedBy: import_zod19.z.string().optional(),
-  discountedFrom: import_zod19.z.enum(discountSources).optional().catch(void 0),
-  message: import_zod19.z.string().optional(),
-  name: import_zod19.z.string().optional(),
-  quantity: import_zod19.z.number().default(1),
-  sectionId: import_zod19.z.uuid().default(() => (0, import_uuid7.v7)()),
-  sectionType: import_zod19.z.literal(SectionType.discount).default(SectionType.discount),
-  type: import_zod19.z.enum(discountTypes).catch("none")
+  amount: import_zod20.z.union([import_zod20.z.number(), import_zod20.z.string()]).catch(0),
+  discountedBy: import_zod20.z.string().optional(),
+  discountedFrom: import_zod20.z.enum(discountSources).optional().catch(void 0),
+  message: import_zod20.z.string().optional(),
+  name: import_zod20.z.string().optional(),
+  quantity: import_zod20.z.number().default(1),
+  sectionId: import_zod20.z.uuid().default(() => (0, import_uuid7.v7)()),
+  sectionType: import_zod20.z.literal(SectionType.discount).default(SectionType.discount),
+  type: import_zod20.z.enum(discountTypes).catch("none")
 });
 
 // src/schema/widgets/checkout-and-beyond/monetize.ts
 var import_uuid8 = require("uuid");
-var import_zod20 = require("zod");
-var CABMonetizeAds = import_zod20.z.object({
-  requestId: import_zod20.z.string().optional(),
+var import_zod21 = require("zod");
+var CABMonetizeAds = import_zod21.z.object({
+  requestId: import_zod21.z.string().optional(),
   /** Defaulted here, never in the beacon: absence of information is `ads` itself being absent. */
-  testing: import_zod20.z.boolean().default(false)
+  testing: import_zod21.z.boolean().default(false)
 });
-var CABMonetizeSection = import_zod20.z.object({
+var CABMonetizeSection = import_zod21.z.object({
   ...CABVariableFields,
   ads: CABMonetizeAds.optional(),
-  name: import_zod20.z.string().optional(),
+  name: import_zod21.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_zod20.z.array(import_zod20.z.lazy(() => CABSection)).optional(),
+  offers: import_zod21.z.array(import_zod21.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_zod20.z.string().optional(),
-  sectionId: import_zod20.z.uuid().default(() => (0, import_uuid8.v7)()),
-  sectionType: import_zod20.z.literal(SectionType.monetize).default(SectionType.monetize),
+  privacyPolicyUrl: import_zod21.z.string().optional(),
+  sectionId: import_zod21.z.uuid().default(() => (0, import_uuid8.v7)()),
+  sectionType: import_zod21.z.literal(SectionType.monetize).default(SectionType.monetize),
   /** Ads-taxonomy sub-vertical id (the widget's `sub_vertical` setting); paired with `vertical`. */
-  subVertical: import_zod20.z.string().optional(),
+  subVertical: import_zod21.z.string().optional(),
   /** Ads-taxonomy vertical id (the widget's `vertical` setting) — with `subVertical`, the admin Monetize editor's two configurables. */
-  vertical: import_zod20.z.string().optional()
+  vertical: import_zod21.z.string().optional()
 });
 
 // src/schema/widgets/checkout-and-beyond/progressBar.ts
-var import_zod21 = require("zod");
+var import_zod22 = require("zod");
 
 // src/schema/widgets/checkout-and-beyond/giftLabels.ts
 var GIFT_LABELS = {
@@ -1762,34 +1771,34 @@ var GIFT_LABELS = {
 };
 
 // src/schema/widgets/checkout-and-beyond/progressBar.ts
-var CABProgressTierExclusion = import_zod21.z.object({
-  collectionIds: import_zod21.z.array(import_zod21.z.number().int().positive()).default(() => []),
-  productIds: import_zod21.z.array(import_zod21.z.number().int().positive()).default(() => []),
-  tags: import_zod21.z.array(import_zod21.z.string().min(1)).default(() => []),
-  type: import_zod21.z.enum(progressTierExclusionTypes)
+var CABProgressTierExclusion = import_zod22.z.object({
+  collectionIds: import_zod22.z.array(import_zod22.z.number().int().positive()).default(() => []),
+  productIds: import_zod22.z.array(import_zod22.z.number().int().positive()).default(() => []),
+  tags: import_zod22.z.array(import_zod22.z.string().min(1)).default(() => []),
+  type: import_zod22.z.enum(progressTierExclusionTypes)
 });
-var CABProgressTier = import_zod21.z.object({
+var CABProgressTier = import_zod22.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_zod21.z.object({ amount: import_zod21.z.number().nonnegative(), type: import_zod21.z.enum(["fixedAmount", "percentage"]) }).optional(),
+  discount: import_zod22.z.object({ amount: import_zod22.z.number().nonnegative(), type: import_zod22.z.enum(["fixedAmount", "percentage"]) }).optional(),
   /**
    * Per-tier exclusion rules (onsite `exclusions` when `exclusions_enabled`): lines they match don't count
    * toward this tier. Empty (the default, and the converter's output for a disabled or ruleless tier) means
    * the tier measures the plain bar-level adjusted progress. Consumers read ONLY the list named by the rule's
    * `type` — the converter leaves the other two at `[]`, so a populated off-type list never reaches the tree.
    */
-  exclusions: import_zod21.z.array(CABProgressTierExclusion).default(() => []),
+  exclusions: import_zod22.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_zod21.z.boolean().default(false),
+  filterOosVariants: import_zod22.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
@@ -1797,10 +1806,10 @@ var CABProgressTier = import_zod21.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_zod21.z.object({
-    productId: import_zod21.z.number().int().positive(),
-    title: import_zod21.z.string().optional(),
-    variantIds: import_zod21.z.array(import_zod21.z.number().int().positive()).default(() => [])
+  gift: import_zod22.z.object({
+    productId: import_zod22.z.number().int().positive(),
+    title: import_zod22.z.string().optional(),
+    variantIds: import_zod22.z.array(import_zod22.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
@@ -1820,7 +1829,7 @@ var CABProgressTier = import_zod21.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_zod21.z.number().int().min(1).max(64).default(18),
+  iconSizePx: import_zod22.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
@@ -1830,35 +1839,35 @@ var CABProgressTier = import_zod21.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_zod21.z.record(import_zod21.z.string(), import_zod21.z.string()).optional(),
+  label: import_zod22.z.record(import_zod22.z.string(), import_zod22.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_zod21.z.boolean().default(false),
+  productTierImage: import_zod22.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_zod21.z.number().int().nonnegative(),
+  threshold: import_zod22.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_zod21.z.record(import_zod21.z.string(), import_zod21.z.number().int().nonnegative()).default(() => ({})),
+  thresholds: import_zod22.z.record(import_zod22.z.string(), import_zod22.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_zod21.z.string().optional(),
-  tierType: import_zod21.z.enum(progressTierTypes).default(ProgressTierType.shipping),
+  tierId: import_zod22.z.string().optional(),
+  tierType: import_zod22.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
@@ -1869,9 +1878,9 @@ var CABProgressTier = import_zod21.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_zod21.z.enum(progressTierUnits).default(ProgressTierUnit.currency)
+  unit: import_zod22.z.enum(progressTierUnits).default(ProgressTierUnit.currency)
 });
-var CABProgressBarSection = import_zod21.z.lazy(
+var CABProgressBarSection = import_zod22.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
@@ -1880,35 +1889,35 @@ var CABProgressBarSection = import_zod21.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_zod21.z.string().optional(),
+    barId: import_zod22.z.string().optional(),
     /** Empty = shown everywhere; otherwise uppercase ISO country codes. */
-    countryCodes: import_zod21.z.array(import_zod21.z.string().transform((code) => code.trim().toUpperCase())).default(() => []),
+    countryCodes: import_zod22.z.array(import_zod22.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_zod21.z.array(import_zod21.z.string().transform((code) => code.trim().toUpperCase())).default(() => []),
+    excludeCountryCodes: import_zod22.z.array(import_zod22.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_zod21.z.boolean().default(false),
+    excludeDiscountInSubtotal: import_zod22.z.boolean().default(false),
     /** Variant ids the client subtracts from the adjusted subtotal (React `bar.excluded_products`). */
-    excludedVariantIds: import_zod21.z.array(import_zod21.z.number().int().positive()).default(() => []),
+    excludedVariantIds: import_zod22.z.array(import_zod22.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_zod21.z.boolean().default(false),
+    freeShippingOnSubscription: import_zod22.z.boolean().default(false),
     /** Localized heading over the gift controls (onsite `gift_area_title`, default 'FREE GIFTS'). */
-    giftAreaTitle: import_zod21.z.record(import_zod21.z.string(), import_zod21.z.string()).default(() => ({ en: "FREE GIFTS" })),
+    giftAreaTitle: import_zod22.z.record(import_zod22.z.string(), import_zod22.z.string()).default(() => ({ en: "FREE GIFTS" })),
     /** Localized gift-control labels (add/remove/heading); a tier's gift `title` beats `yourGift`. */
-    giftLabels: import_zod21.z.object({
-      addGift: import_zod21.z.record(import_zod21.z.string(), import_zod21.z.string()).default(() => ({ ...GIFT_LABELS.addGift })),
-      remove: import_zod21.z.record(import_zod21.z.string(), import_zod21.z.string()).default(() => ({ ...GIFT_LABELS.remove })),
-      selectOptions: import_zod21.z.record(import_zod21.z.string(), import_zod21.z.string()).default(() => ({ ...GIFT_LABELS.selectOptions })),
-      yourGift: import_zod21.z.record(import_zod21.z.string(), import_zod21.z.string()).default(() => ({ ...GIFT_LABELS.yourGift }))
+    giftLabels: import_zod22.z.object({
+      addGift: import_zod22.z.record(import_zod22.z.string(), import_zod22.z.string()).default(() => ({ ...GIFT_LABELS.addGift })),
+      remove: import_zod22.z.record(import_zod22.z.string(), import_zod22.z.string()).default(() => ({ ...GIFT_LABELS.remove })),
+      selectOptions: import_zod22.z.record(import_zod22.z.string(), import_zod22.z.string()).default(() => ({ ...GIFT_LABELS.selectOptions })),
+      yourGift: import_zod22.z.record(import_zod22.z.string(), import_zod22.z.string()).default(() => ({ ...GIFT_LABELS.yourGift }))
     }).default(() => ({
       addGift: { ...GIFT_LABELS.addGift },
       remove: { ...GIFT_LABELS.remove },
@@ -1916,38 +1925,38 @@ var CABProgressBarSection = import_zod21.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_zod21.z.string().default("Order progress"),
+    name: import_zod22.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_zod21.z.string().optional(),
-    sectionType: import_zod21.z.literal(SectionType.progressBar).default(SectionType.progressBar),
+    progressColor: import_zod22.z.string().optional(),
+    sectionType: import_zod22.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_zod21.z.union([import_zod21.z.array(CABProgressTier), import_zod21.z.strictObject({}).transform(() => [])]).default(() => [])
+    tiers: import_zod22.z.union([import_zod22.z.array(CABProgressTier), import_zod22.z.strictObject({}).transform(() => [])]).default(() => [])
   })
 );
 
 // src/schema/widgets/checkout-and-beyond/quantity.ts
 var import_uuid9 = require("uuid");
-var import_zod22 = require("zod");
-var CABQuantitySection = import_zod22.z.object({
+var import_zod23 = require("zod");
+var CABQuantitySection = import_zod23.z.object({
   ...CABVariableFields,
-  errorMessages: import_zod22.z.record(
-    import_zod22.z.string(),
-    import_zod22.z.object({
+  errorMessages: import_zod23.z.record(
+    import_zod23.z.string(),
+    import_zod23.z.object({
       /** `{{step}}` is interpolated at render — the off-increment message React never gave a merchant key. */
-      increment: import_zod22.z.string().optional(),
-      max: import_zod22.z.string().optional(),
-      min: import_zod22.z.string().optional(),
-      neg: import_zod22.z.string().optional()
+      increment: import_zod23.z.string().optional(),
+      max: import_zod23.z.string().optional(),
+      min: import_zod23.z.string().optional(),
+      neg: import_zod23.z.string().optional()
     })
   ).default({
     en: {
@@ -1957,18 +1966,18 @@ var CABQuantitySection = import_zod22.z.object({
       neg: "Quantity cannot be negative"
     }
   }),
-  inputType: import_zod22.z.enum(quantityInputs).default(QuantityInput.select),
-  max: import_zod22.z.number().min(1).max(100).default(10),
-  min: import_zod22.z.number().min(1).default(1),
+  inputType: import_zod23.z.enum(quantityInputs).default(QuantityInput.select),
+  max: import_zod23.z.number().min(1).max(100).default(10),
+  min: import_zod23.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_zod22.z.string().default("Quantity"),
-  sectionId: import_zod22.z.uuid().default(() => (0, import_uuid9.v7)()),
-  sectionType: import_zod22.z.literal(SectionType.quantity).default(SectionType.quantity)
+  name: import_zod23.z.string().default("Quantity"),
+  sectionId: import_zod23.z.uuid().default(() => (0, import_uuid9.v7)()),
+  sectionType: import_zod23.z.literal(SectionType.quantity).default(SectionType.quantity)
 });
 
 // src/schema/widgets/checkout-and-beyond/reviews.ts
 var import_uuid10 = require("uuid");
-var import_zod23 = require("zod");
+var import_zod24 = require("zod");
 
 // src/schema/widgets/checkout-and-beyond/reviewLabels.ts
 var REVIEW_LABELS = {
@@ -2031,68 +2040,69 @@ var REVIEW_LABELS = {
 };
 
 // src/schema/widgets/checkout-and-beyond/reviews.ts
-var CABReviewsSection = import_zod23.z.object({
+var CABReviewsSection = import_zod24.z.object({
   ...CABVariableFields,
-  color: import_zod23.z.string().default("#fadb14"),
+  color: import_zod24.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_zod23.z.object({
-    one: import_zod23.z.record(import_zod23.z.string(), import_zod23.z.string()).default(() => ({ ...REVIEW_LABELS.one })),
-    other: import_zod23.z.record(import_zod23.z.string(), import_zod23.z.string()).default(() => ({ ...REVIEW_LABELS.other }))
+  countLabels: import_zod24.z.object({
+    one: import_zod24.z.record(import_zod24.z.string(), import_zod24.z.string()).default(() => ({ ...REVIEW_LABELS.one })),
+    other: import_zod24.z.record(import_zod24.z.string(), import_zod24.z.string()).default(() => ({ ...REVIEW_LABELS.other }))
   }).default(() => ({ one: { ...REVIEW_LABELS.one }, other: { ...REVIEW_LABELS.other } })),
-  name: import_zod23.z.string().optional(),
-  sectionId: import_zod23.z.uuid().default(() => (0, import_uuid10.v7)()),
-  sectionType: import_zod23.z.literal(SectionType.reviews).default(SectionType.reviews),
-  size: import_zod23.z.enum(reviewsSizes).default(ReviewsSize.default),
+  name: import_zod24.z.string().optional(),
+  sectionId: import_zod24.z.uuid().default(() => (0, import_uuid10.v7)()),
+  sectionType: import_zod24.z.literal(SectionType.reviews).default(SectionType.reviews),
+  size: import_zod24.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_zod23.z.string().regex(HEX_COLOR_REGEX).default("#fadb14"),
+  strokeColor: import_zod24.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_zod23.z.number().nonnegative().default(0)
+  strokeWidth: import_zod24.z.number().nonnegative().default(0)
 });
 
 // src/schema/widgets/checkout-and-beyond/separator.ts
 var import_uuid11 = require("uuid");
-var import_zod24 = require("zod");
-var CABSeparatorSection = import_zod24.z.object({
+var import_zod25 = require("zod");
+var CABSeparatorSection = import_zod25.z.object({
   ...CABVariableFields,
-  sectionId: import_zod24.z.uuid().default(() => (0, import_uuid11.v7)()),
-  sectionType: import_zod24.z.literal(SectionType.separator).default(SectionType.separator)
+  sectionId: import_zod25.z.uuid().default(() => (0, import_uuid11.v7)()),
+  sectionType: import_zod25.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_zod25 = require("zod");
-var CABVariantsSection = import_zod25.z.object({
+var import_zod26 = require("zod");
+var CABVariantsSection = import_zod26.z.object({
   ...CABVariableFields,
-  hideOutOfStockVariants: import_zod25.z.boolean().default(false),
-  name: import_zod25.z.string().optional(),
-  sectionId: import_zod25.z.uuid().default(() => (0, import_uuid12.v7)()),
-  sectionType: import_zod25.z.literal(SectionType.variants).default(SectionType.variants),
-  selector: import_zod25.z.enum((0, import_compat3.slice)(variantSelectors, 0, 3)).default(VariantSelector.menu),
-  variantMode: import_zod25.z.enum(variantModes).default(VariantMode.multiple)
+  hideOutOfStockVariants: import_zod26.z.boolean().default(false),
+  name: import_zod26.z.string().optional(),
+  sectionId: import_zod26.z.uuid().default(() => (0, import_uuid12.v7)()),
+  sectionType: import_zod26.z.literal(SectionType.variants).default(SectionType.variants),
+  selector: import_zod26.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_zod26.z.enum(variantsModes).default(VariantsMode.multiple)
 });
 
 // src/schema/widgets/checkout-and-beyond/shared.ts
-var CABBorder = import_zod26.z.object({
-  radius: import_zod26.z.enum(borderRadii).default(BorderRadius.base),
-  style: import_zod26.z.enum(borderStyles).default(BorderStyle.none),
-  width: import_zod26.z.enum(borderWidths).default(BorderWidth.base)
+var CABBorder = import_zod27.z.object({
+  radius: import_zod27.z.enum(borderRadii).default(BorderRadius.base),
+  style: import_zod27.z.enum(borderStyles).default(BorderStyle.none),
+  width: import_zod27.z.enum(borderWidths).default(BorderWidth.base)
 }).default({
   radius: BorderRadius.base,
   style: BorderStyle.none,
   width: BorderWidth.base
 });
-var CABSection = import_zod26.z.lazy(
-  () => import_zod26.z.discriminatedUnion("sectionType", [
+var CABSection = import_zod27.z.lazy(
+  () => import_zod27.z.discriminatedUnion("sectionType", [
     CABBannerSection,
     CABButtonSection,
     CABCarouselSection,
@@ -2115,17 +2125,17 @@ var CABSection = import_zod26.z.lazy(
 );
 
 // src/schema/widgets/checkout-and-beyond/image.ts
-var CABImageSectionFields = import_zod27.z.object({
+var CABImageSectionFields = import_zod28.z.object({
   ...CABVariableFields,
-  altText: import_zod27.z.string().refine(checkForHTML, NO_HTML).default(""),
+  altText: import_zod28.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_zod27.z.number().positive().nullable().default(null),
-  border: import_zod27.z.lazy(() => CABBorder),
-  buttonField: import_zod27.z.enum(buttonFields).optional(),
+  aspectRatio: import_zod28.z.number().positive().nullable().default(null),
+  border: import_zod28.z.lazy(() => CABBorder),
+  buttonField: import_zod28.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
@@ -2144,29 +2154,30 @@ var CABImageSectionFields = import_zod27.z.object({
    * behavior degraded gracefully and told us about it. The client-assembled half of the invariant was never
    * the risky half.
    */
-  category: import_zod27.z.enum(["gallery", "icon", "icons", "payment-methods", "secure-checkout"]).nullable().default(null),
+  category: import_zod28.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_zod27.z.enum(iconSizes).nullable().default(null),
+  iconSize: import_zod28.z.enum(iconSizes).nullable().default(null),
   /** `icon`-mode only: the `s-icon` `tone`; `null` ⇒ the component default (`auto`). Ignored by image treatments. */
-  iconTone: import_zod27.z.enum(iconTones).nullable().default(null),
-  name: import_zod27.z.string().optional(),
-  naturalHeight: import_zod27.z.number().default(0),
-  naturalWidth: import_zod27.z.number().default(0),
+  iconTone: import_zod28.z.enum(iconTones).nullable().default(null),
+  name: import_zod28.z.string().optional(),
+  naturalHeight: import_zod28.z.number().default(0),
+  naturalWidth: import_zod28.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_zod27.z.enum(objectFits).default(ObjectFit.contain),
-  sectionId: import_zod27.z.uuid().default(() => (0, import_uuid13.v7)()),
-  sectionType: import_zod27.z.literal(SectionType.image).default(SectionType.image),
+  objectFit: import_zod28.z.enum(objectFits).default(ObjectFit.contain),
+  sectionId: import_zod28.z.uuid().default(() => (0, import_uuid13.v7)()),
+  sectionType: import_zod28.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_zod27.z.union([import_zod27.z.url(), import_zod27.z.literal(""), import_zod27.z.string().regex(DYNAMIC_TOKEN_REGEX), import_zod27.z.enum(iconNames)]).default(""),
-  width: import_zod27.z.number().default(100)
+  source: import_zod28.z.union([import_zod28.z.url(), import_zod28.z.literal(""), import_zod28.z.string().regex(DYNAMIC_TOKEN_REGEX), import_zod28.z.enum(iconNames)]).default(""),
+  thumbnails: CABImageThumbnails.optional(),
+  width: import_zod28.z.number().default(100)
 });
 var iconNameSet = new Set(iconNames);
 var isIconName = (source2) => iconNameSet.has(source2);
@@ -2317,7 +2328,7 @@ var convertContentBlockTextToV2 = (language3, text2 = literalText, textAlign = "
 };
 
 // src/schema/widgets/checkout-and-beyond/root.ts
-var import_zod28 = require("zod");
+var import_zod29 = require("zod");
 
 // src/schema/widgets/checkout-and-beyond/uiLabels.ts
 var UI_LABELS = {
@@ -2337,8 +2348,8 @@ var UI_LABELS = {
 };
 
 // src/schema/widgets/checkout-and-beyond/root.ts
-var localized = (fallback) => import_zod28.z.record(import_zod28.z.string(), import_zod28.z.string()).default(() => ({ ...fallback })).transform((labels) => Object.keys(labels).length > 0 ? labels : { ...fallback });
-var CABUILabels = import_zod28.z.object({
+var localized = (fallback) => import_zod29.z.record(import_zod29.z.string(), import_zod29.z.string()).default(() => ({ ...fallback })).transform((labels) => Object.keys(labels).length > 0 ? labels : { ...fallback });
+var CABUILabels = import_zod29.z.object({
   currentPage: localized(UI_LABELS.currentPage),
   guest: localized(UI_LABELS.guest),
   loadingOptions: localized(UI_LABELS.loadingOptions),
@@ -2363,37 +2374,37 @@ var CABUILabels = import_zod28.z.object({
   subscriptionOptions: { ...UI_LABELS.subscriptionOptions },
   updating: { ...UI_LABELS.updating }
 }));
-var TargetArea = import_zod28.z.object({
-  fill: import_zod28.z.boolean().optional(),
-  flip: import_zod28.z.enum(["both", "horizontal", "vertical"]).optional(),
-  icon: import_zod28.z.string(),
-  label: import_zod28.z.string(),
-  width: import_zod28.z.string()
+var TargetArea = import_zod29.z.object({
+  fill: import_zod29.z.boolean().optional(),
+  flip: import_zod29.z.enum(["both", "horizontal", "vertical"]).optional(),
+  icon: import_zod29.z.string(),
+  label: import_zod29.z.string(),
+  width: import_zod29.z.string()
 }).default(targetAreas[EditorMode.checkoutExtension][1]);
-var CABTracking = import_zod28.z.object({
-  enableAttribution: import_zod28.z.boolean().nullish().transform((value) => value ?? true),
-  enableSource: import_zod28.z.boolean().nullish().transform((value) => value ?? true),
-  enableWidget: import_zod28.z.boolean().nullish().transform((value) => value ?? true)
+var CABTracking = import_zod29.z.object({
+  enableAttribution: import_zod29.z.boolean().nullish().transform((value) => value ?? true),
+  enableSource: import_zod29.z.boolean().nullish().transform((value) => value ?? true),
+  enableWidget: import_zod29.z.boolean().nullish().transform((value) => value ?? true)
 }).nullish().transform((value) => value ?? { enableAttribution: true, enableSource: true, enableWidget: true });
-var CABExperiment = import_zod28.z.object({
-  elementId: import_zod28.z.number(),
-  experimentId: import_zod28.z.number(),
-  experimentType: import_zod28.z.string(),
-  selectedId: import_zod28.z.number()
+var CABExperiment = import_zod29.z.object({
+  elementId: import_zod29.z.number(),
+  experimentId: import_zod29.z.number(),
+  experimentType: import_zod29.z.string(),
+  selectedId: import_zod29.z.number()
 });
 var CABRootSection = CABLayoutSection.extend({
-  editorMode: import_zod28.z.enum(editorModes).default(EditorMode.checkoutExtension),
+  editorMode: import_zod29.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_zod28.z.boolean().nullish().transform((value) => value ?? false),
-  storeId: import_zod28.z.number().nullable().default(null),
+  previewMode: import_zod29.z.boolean().nullish().transform((value) => value ?? false),
+  storeId: import_zod29.z.number().nullable().default(null),
   targetArea: TargetArea.nullable(),
   tracking: CABTracking,
-  type: import_zod28.z.enum(widgetTypes).default(WidgetType.ui_extension_content_block),
+  type: import_zod29.z.enum(widgetTypes).default(WidgetType.ui_extension_content_block),
   uiLabels: CABUILabels,
-  version: import_zod28.z.literal(2).default(2),
-  widgetId: import_zod28.z.number().nullable().default(null)
+  version: import_zod29.z.literal(2).default(2),
+  widgetId: import_zod29.z.number().nullable().default(null)
 });
 
 // src/transforms/v1Location.ts
@@ -3231,21 +3242,26 @@ var convertPlaceholderToV2 = ({ id, settings }) => CABRootSection.parse({
 // src/transforms/placeholderV1/types.ts
 var isPlaceholderV1 = (data) => !!data && typeof data === "object" && data.type === WidgetType.placeholder;
 
-// src/transforms/offerV1/offerCard.ts
-var borderToken = (tokens, value) => value !== void 0 && tokens.includes(value) ? value : "base";
-var GRID_CARD_IMAGE_PX = 120;
-var COMPACT_CARD_IMAGE_PX = 64;
-var ADD_LABEL_TOKENS = ["quantity", "price", "total"];
-var SWITCH_LABEL_TOKENS2 = ["subscriptionDiscount", "frequency", "interval"];
-var QUANTITY_ERROR_TOKENS = ["max", "min", "step"];
-var VARIANT_SELECTOR = { button: "button", radio: "radio", select: "menu" };
-var buildStyledText = (token, style, fontSize = style?.textSize ?? "base") => {
-  const marks2 = [{ attrs: { color: "base", fontSize }, type: "textStyle" }];
-  if (style?.textEmphasis === "bold") marks2.push({ type: "bold" });
-  if (style?.textEmphasis === "italic") marks2.push({ type: "italic" });
-  return { content: [{ content: [{ marks: marks2, text: token, type: "text" }], type: "paragraph" }], type: "doc" };
-};
-var buildPriceContent = () => ({
+// src/transforms/productCard/earnedText.ts
+var contentMutator = (effect, variable, operator) => ({
+  effect,
+  variable,
+  when: { operator, type: "content" }
+});
+var earnedFrom = (variable) => [
+  contentMutator("set_false", variable, "is_empty"),
+  contentMutator("set_true", variable, "is_not_empty")
+];
+var shownWhile = (variable) => ({ variable, visibleWhen: true });
+var earnedText = (variable, content) => ({
+  content: { en: content },
+  mutators: earnedFrom(variable),
+  sectionType: "text",
+  visibility: shownWhile(variable)
+});
+
+// src/transforms/productCard/priceText.ts
+var priceContent = () => ({
   content: [
     {
       content: [
@@ -3271,6 +3287,64 @@ var buildPriceContent = () => ({
   ],
   type: "doc"
 });
+var priceText = () => ({
+  content: { en: priceContent() },
+  sectionType: "text"
+});
+
+// src/transforms/productCard/quantitySection.ts
+var quantitySection = ({ errorMessages, inputType, maxValue, minValue, name }) => {
+  const max = Math.min(Math.max(maxValue ?? 10, 1), 100);
+  const min = Math.min(Math.max(minValue ?? 1, 1), max);
+  return {
+    ...errorMessages && { errorMessages },
+    ...inputType && { inputType },
+    max,
+    min,
+    ...name && { name },
+    sectionType: "quantity"
+  };
+};
+
+// src/transforms/productCard/subscriptionToggle.ts
+var SWITCH_LABEL_TOKENS2 = ["subscriptionDiscount", "frequency", "interval"];
+var subscriptionToggle = (productType, labels = {}) => {
+  if (productType !== "both" && productType !== "subscription") return [];
+  const slot = (buttonField, override) => ({
+    buttonField,
+    content: localizedContent(SWITCH_LABELS[buttonField], override, SWITCH_LABEL_TOKENS2),
+    sectionType: "text"
+  });
+  return [
+    {
+      action: "switchToSubscription",
+      buttonStyle: "plain",
+      /** A `subscription` widget offers no one-time purchase; suppress the downgrade so the buyer can't switch to one-time. */
+      ...productType === "subscription" && { disableDowngrade: true },
+      sections: [
+        slot("subscriptionOption", void 0),
+        slot("switchToOneTimePurchase", labels.oneTime),
+        slot("switchToSubscriptionNoDiscount", labels.upgrade),
+        slot("switchToSubscriptionWithDiscount", labels.upgrade)
+      ],
+      sectionType: "button"
+    }
+  ];
+};
+
+// src/transforms/offerV1/offerCard.ts
+var borderToken = (tokens, value) => value !== void 0 && tokens.includes(value) ? value : "base";
+var GRID_CARD_IMAGE_PX = 120;
+var COMPACT_CARD_IMAGE_PX = 64;
+var ADD_LABEL_TOKENS = ["quantity", "price", "total"];
+var QUANTITY_ERROR_TOKENS = ["max", "min", "step"];
+var VARIANT_SELECTOR = { button: "button", radio: "radio", select: "menu" };
+var buildStyledText = (token, style, fontSize = style?.textSize ?? "base") => {
+  const marks2 = [{ attrs: { color: "base", fontSize }, type: "textStyle" }];
+  if (style?.textEmphasis === "bold") marks2.push({ type: "bold" });
+  if (style?.textEmphasis === "italic") marks2.push({ type: "italic" });
+  return { content: [{ content: [{ marks: marks2, text: token, type: "text" }], type: "paragraph" }], type: "doc" };
+};
 var buildReviews = (settings) => {
   if (!settings.integrations || !Object.values(settings.integrations).some(Boolean)) return [];
   const reviews = settings.displaySettings?.reviews;
@@ -3312,29 +3386,11 @@ var buildTitle = (settings) => ({
   },
   sectionType: "text"
 });
-var buildPrice = () => ({
-  content: { en: buildPriceContent() },
-  sectionType: "text"
-});
 var HAS_VARIANT_TITLE = "hasVariantTitle";
 var buildVariantTitle = (settings) => {
   const show = settings.productOptions?.showVariantTitle;
   if (!show || show === "hide") return [];
-  return [
-    {
-      content: { en: buildStyledText("{{variantTitle}}", settings.displaySettings?.variant) },
-      mutators: [
-        { effect: "set_false", variable: HAS_VARIANT_TITLE, when: { operator: "is_empty", type: "content" } },
-        {
-          effect: "set_true",
-          variable: HAS_VARIANT_TITLE,
-          when: { operator: "is_not_empty", type: "content" }
-        }
-      ],
-      sectionType: "text",
-      visibility: { variable: HAS_VARIANT_TITLE, visibleWhen: true }
-    }
-  ];
+  return [earnedText(HAS_VARIANT_TITLE, buildStyledText("{{variantTitle}}", settings.displaySettings?.variant))];
 };
 var detailBlock = (sections, horizontal, hasVariantTitleLine) => ({
   alignment: { horizontal: horizontal ? "start" : "center", vertical: "top" },
@@ -3363,18 +3419,7 @@ var buildDescription = (settings) => {
         },
         {
           content: { en: buildStyledText("{{productDescription}}", void 0) },
-          mutators: [
-            {
-              effect: "set_false",
-              variable: HAS_DESCRIPTION,
-              when: { operator: "is_empty", type: "content" }
-            },
-            {
-              effect: "set_true",
-              variable: HAS_DESCRIPTION,
-              when: { operator: "is_not_empty", type: "content" }
-            }
-          ],
+          mutators: earnedFrom(HAS_DESCRIPTION),
           sectionType: "text",
           visibility: { variable: SHOW_DESCRIPTION, visibleWhen: true }
         }
@@ -3390,7 +3435,7 @@ var buildDescription = (settings) => {
 var SHOW_VARIANTS = "showVariants";
 var REVEAL_PENDING = "revealPending";
 var revealsVariants = (settings) => settings.viewOptions?.displayActions !== false && settings.productOptions?.showVariantOptions === "default";
-var contentMutator = (effect, variable, operator) => ({
+var contentMutator2 = (effect, variable, operator) => ({
   effect,
   variable,
   when: { operator, type: "content" }
@@ -3404,10 +3449,10 @@ var buildVariants = (settings) => {
       hideOutOfStockVariants: !!settings.productOptions?.hideOutOfStockVariants,
       ...revealsVariants(settings) && {
         mutators: [
-          contentMutator("set_true", SHOW_VARIANTS, "is_empty"),
-          contentMutator("set_false", REVEAL_PENDING, "is_empty"),
-          contentMutator("set_true", REVEAL_PENDING, "is_not_empty"),
-          contentMutator("set_false", SHOW_VARIANTS, "is_not_empty")
+          contentMutator2("set_true", SHOW_VARIANTS, "is_empty"),
+          contentMutator2("set_false", REVEAL_PENDING, "is_empty"),
+          contentMutator2("set_true", REVEAL_PENDING, "is_not_empty"),
+          contentMutator2("set_false", SHOW_VARIANTS, "is_not_empty")
         ]
       },
       ...selector && { selector: VARIANT_SELECTOR[selector] },
@@ -3421,54 +3466,31 @@ var QUANTITY_INPUT_TYPE = {
   "buttons-manual-input": "number",
   "dropdown-select": "select"
 };
-var buildQuantityErrors = (quantity2) => {
+var buildQuantityErrors = (quantity3) => {
   const en = {
-    ...quantity2.maxError && { max: normalizeTokens(quantity2.maxError, QUANTITY_ERROR_TOKENS) },
-    ...quantity2.minError && { min: normalizeTokens(quantity2.minError, QUANTITY_ERROR_TOKENS) },
-    ...quantity2.negativeError && { neg: normalizeTokens(quantity2.negativeError, QUANTITY_ERROR_TOKENS) }
+    ...quantity3.maxError && { max: normalizeTokens(quantity3.maxError, QUANTITY_ERROR_TOKENS) },
+    ...quantity3.minError && { min: normalizeTokens(quantity3.minError, QUANTITY_ERROR_TOKENS) },
+    ...quantity3.negativeError && { neg: normalizeTokens(quantity3.negativeError, QUANTITY_ERROR_TOKENS) }
   };
   return Object.keys(en).length ? { errorMessages: { en } } : {};
 };
 var buildQuantity = (settings) => {
-  const quantity2 = settings.quantityInputs;
-  if (!quantity2?.enabled) return [];
-  const inputType = quantity2.type ? QUANTITY_INPUT_TYPE[quantity2.type] : void 0;
-  const max = Math.min(Math.max(quantity2.maxValue ?? 10, 1), 100);
-  const min = Math.min(Math.max(quantity2.minValue ?? 1, 1), max);
-  return [
-    {
-      ...buildQuantityErrors(quantity2),
-      ...inputType && { inputType },
-      max,
-      min,
-      sectionType: "quantity"
-    }
-  ];
-};
-var buildSubscriptionButton = (settings) => {
-  if (settings.productType !== "both" && settings.productType !== "subscription") return [];
-  const language3 = settings.language;
-  const slot = (buttonField, override) => ({
-    buttonField,
-    content: localizedContent(SWITCH_LABELS[buttonField], override, SWITCH_LABEL_TOKENS2),
-    sectionType: "text"
-  });
+  const quantity3 = settings.quantityInputs;
+  if (!quantity3?.enabled) return [];
+  const errors = buildQuantityErrors(quantity3);
   return [
-    {
-      action: "switchToSubscription",
-      buttonStyle: "plain",
-      /** A `subscription` widget offers no one-time purchase (legacy's offers checkbox renders only when `isProductTypeBoth`); suppress the downgrade so the buyer can't switch to one-time on a subscription-only offer. */
-      ...settings.productType === "subscription" && { disableDowngrade: true },
-      sections: [
-        slot("subscriptionOption", void 0),
-        slot("switchToOneTimePurchase", language3?.cartSwitchToOnetime),
-        slot("switchToSubscriptionNoDiscount", language3?.upgradeToSubscription),
-        slot("switchToSubscriptionWithDiscount", language3?.upgradeToSubscription)
-      ],
-      sectionType: "button"
-    }
+    quantitySection({
+      ...errors,
+      inputType: quantity3.type ? QUANTITY_INPUT_TYPE[quantity3.type] : void 0,
+      maxValue: quantity3.maxValue,
+      minValue: quantity3.minValue
+    })
   ];
 };
+var buildSubscriptionButton = (settings) => subscriptionToggle(settings.productType, {
+  oneTime: settings.language?.cartSwitchToOnetime,
+  upgrade: settings.language?.upgradeToSubscription
+});
 var BUTTON_KINDS2 = ["plain", "primary", "secondary"];
 var buttonKind = (settings) => {
   const kind = settings.button?.kind;
@@ -3514,15 +3536,15 @@ var buildOfferCard = (settings, horizontal) => {
   const image = buildImage(settings);
   const title = buildTitle(settings);
   const variantTitle = buildVariantTitle(settings);
-  const price = buildPrice();
+  const price = priceText();
   const description = buildDescription(settings);
   const reviews = buildReviews(settings);
   const variants = buildVariants(settings);
-  const quantity2 = buildQuantity(settings);
+  const quantity3 = buildQuantity(settings);
   const subscription2 = buildSubscriptionButton(settings);
   const reveal = buildRevealButton(settings);
   const addButton = buildAddButton(settings);
-  const controls = [...description, ...quantity2, ...variants, ...subscription2];
+  const controls = [...description, ...quantity3, ...variants, ...subscription2];
   const info = detailBlock([title, ...variantTitle, ...reviews, price], horizontal, variantTitle.length > 0);
   const card = (sections) => [
     {
@@ -3818,18 +3840,18 @@ var convertOfferToV2 = ({ id, name, settings }) => {
 var parseShielded = (schema, raw, transform = (input) => input) => schema.parse(transform(convertNumericObjects(deepCamelCase(raw))));
 
 // src/transforms/postPurchase/convertMessagePreview.ts
-var import_zod36 = require("zod");
+var import_zod40 = require("zod");
 
 // src/transforms/postPurchase/convertCalloutBlock.ts
-var import_zod31 = require("zod");
+var import_zod32 = require("zod");
 
 // src/schema/widgets/post-purchase-offer/postPurchaseBlocks.ts
 var import_compat4 = require("es-toolkit/compat");
 var import_uuid14 = require("uuid");
-var import_zod30 = require("zod");
+var import_zod31 = require("zod");
 
 // src/schema/widgets/post-purchase-offer/constants.ts
-var import_zod29 = require("zod");
+var import_zod30 = require("zod");
 var blockTypes = [
   "callout_banner",
   "image",
@@ -3840,141 +3862,141 @@ var blockTypes = [
   "text",
   "timer"
 ];
-var blockType = import_zod29.z.enum(blockTypes);
+var blockType = import_zod30.z.enum(blockTypes);
 var BlockType = blockType.enum;
 
 // src/schema/widgets/post-purchase-offer/postPurchaseBlocks.ts
-var TextAlignment2 = import_zod30.z.union([import_zod30.z.enum(["leading", "center", "trailing"]), import_zod30.z.unknown().transform(() => "leading")]);
-var TextSize = import_zod30.z.union([
-  import_zod30.z.enum(["xsmall", "small", "base", "default", "medium", "large", "xlarge"]),
-  import_zod30.z.unknown().transform(() => "medium")
+var TextAlignment2 = import_zod31.z.union([import_zod31.z.enum(["leading", "center", "trailing"]), import_zod31.z.unknown().transform(() => "leading")]);
+var TextSize = import_zod31.z.union([
+  import_zod31.z.enum(["xsmall", "small", "base", "default", "medium", "large", "xlarge"]),
+  import_zod31.z.unknown().transform(() => "medium")
 ]);
-var CalloutBannerBlock = import_zod30.z.object({
-  id: import_zod30.z.string().optional().default(() => (0, import_uuid14.v4)()),
-  name: import_zod30.z.string().optional(),
-  settings: import_zod30.z.object({
-    superTitle: import_zod30.z.union([import_zod30.z.string(), TiptapDocument]).default(() => "Limited-time Offer"),
-    title: import_zod30.z.union([import_zod30.z.string(), TiptapDocument]).default(() => "Add this customer favorite to your order")
+var CalloutBannerBlock = import_zod31.z.object({
+  id: import_zod31.z.string().optional().default(() => (0, import_uuid14.v4)()),
+  name: import_zod31.z.string().optional(),
+  settings: import_zod31.z.object({
+    superTitle: import_zod31.z.union([import_zod31.z.string(), TiptapDocument]).default(() => "Limited-time Offer"),
+    title: import_zod31.z.union([import_zod31.z.string(), TiptapDocument]).default(() => "Add this customer favorite to your order")
   }),
-  styles: import_zod30.z.object({
-    superTitleEmphasized: import_zod30.z.boolean().default(false),
+  styles: import_zod31.z.object({
+    superTitleEmphasized: import_zod31.z.boolean().default(false),
     superTitleSize: TextSize.default("large"),
     textAlignment: TextAlignment2.default("center"),
-    titleEmphasized: import_zod30.z.boolean().default(true),
+    titleEmphasized: import_zod31.z.boolean().default(true),
     titleSize: TextSize.default("large")
   }),
-  type: import_zod30.z.literal(BlockType.callout_banner).default(BlockType.callout_banner)
+  type: import_zod31.z.literal(BlockType.callout_banner).default(BlockType.callout_banner)
 });
-var ImageBlock = import_zod30.z.object({
-  id: import_zod30.z.string().optional().default(() => (0, import_uuid14.v4)()),
-  name: import_zod30.z.string().optional(),
-  settings: import_zod30.z.union([
-    import_zod30.z.object({
+var ImageBlock = import_zod31.z.object({
+  id: import_zod31.z.string().optional().default(() => (0, import_uuid14.v4)()),
+  name: import_zod31.z.string().optional(),
+  settings: import_zod31.z.union([
+    import_zod31.z.object({
       /** This isn't used in the post-purchase offer widget */
-      alt: import_zod30.z.string().optional().default(""),
-      image: import_zod30.z.union([import_zod30.z.literal(""), import_zod30.z.url()]).default(""),
-      imageSize: import_zod30.z.number().default(20),
-      imageType: import_zod30.z.enum(["URL", "UPLOAD"]).default("URL")
+      alt: import_zod31.z.string().optional().default(""),
+      image: import_zod31.z.union([import_zod31.z.literal(""), import_zod31.z.url()]).default(""),
+      imageSize: import_zod31.z.number().default(20),
+      imageType: import_zod31.z.enum(["URL", "UPLOAD"]).default("URL")
     }),
-    import_zod30.z.array(import_zod30.z.never()).transform(() => ({}))
+    import_zod31.z.array(import_zod31.z.never()).transform(() => ({}))
   ]),
-  type: import_zod30.z.literal(BlockType.image).default(BlockType.image)
-});
-var ImageContentBlock = import_zod30.z.object({
-  id: import_zod30.z.string().optional().default(() => (0, import_uuid14.v4)()),
-  name: import_zod30.z.string().optional(),
-  settings: import_zod30.z.object({
-    alt: import_zod30.z.string().optional().default(""),
-    description: import_zod30.z.union([import_zod30.z.string(), TiptapDocument, import_zod30.z.null()]).default(
+  type: import_zod31.z.literal(BlockType.image).default(BlockType.image)
+});
+var ImageContentBlock = import_zod31.z.object({
+  id: import_zod31.z.string().optional().default(() => (0, import_uuid14.v4)()),
+  name: import_zod31.z.string().optional(),
+  settings: import_zod31.z.object({
+    alt: import_zod31.z.string().optional().default(""),
+    description: import_zod31.z.union([import_zod31.z.string(), TiptapDocument, import_zod31.z.null()]).default(
       "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum."
     ),
     descriptionSize: TextSize.default("medium"),
     horizontalAlignment: TextAlignment2.default("leading"),
-    image: import_zod30.z.union([import_zod30.z.literal(""), import_zod30.z.url()]).default(""),
-    imagePlacement: import_zod30.z.enum(["bottom", "left", "right", "top"]).optional().default("left"),
-    imageSize: import_zod30.z.number().default(20),
-    superTitle: import_zod30.z.union([import_zod30.z.string(), TiptapDocument]).default("Lorem Ipsum!"),
+    image: import_zod31.z.union([import_zod31.z.literal(""), import_zod31.z.url()]).default(""),
+    imagePlacement: import_zod31.z.enum(["bottom", "left", "right", "top"]).optional().default("left"),
+    imageSize: import_zod31.z.number().default(20),
+    superTitle: import_zod31.z.union([import_zod31.z.string(), TiptapDocument]).default("Lorem Ipsum!"),
     superTitleSize: TextSize.default("medium"),
     /** This isn't configurable in the admin-nextjs editor */
-    swapContent: import_zod30.z.boolean().optional().default(false),
-    title: import_zod30.z.union([import_zod30.z.string(), TiptapDocument]).nullable().default("Lorem ipsum dolor sit amet"),
+    swapContent: import_zod31.z.boolean().optional().default(false),
+    title: import_zod31.z.union([import_zod31.z.string(), TiptapDocument]).nullable().default("Lorem ipsum dolor sit amet"),
     titleSize: TextSize.default("medium")
   }),
-  type: import_zod30.z.literal(BlockType.image_content).default(BlockType.image_content)
-});
-var PayButtonBlock = import_zod30.z.object({
-  id: import_zod30.z.string().optional().default(() => (0, import_uuid14.v4)()),
-  name: import_zod30.z.string().optional(),
-  settings: import_zod30.z.union([
-    import_zod30.z.object({
-      label: import_zod30.z.string().default("Pay Now")
+  type: import_zod31.z.literal(BlockType.image_content).default(BlockType.image_content)
+});
+var PayButtonBlock = import_zod31.z.object({
+  id: import_zod31.z.string().optional().default(() => (0, import_uuid14.v4)()),
+  name: import_zod31.z.string().optional(),
+  settings: import_zod31.z.union([
+    import_zod31.z.object({
+      label: import_zod31.z.string().default("Pay Now")
     }),
-    import_zod30.z.array(import_zod30.z.never()).transform(() => ({
+    import_zod31.z.array(import_zod31.z.never()).transform(() => ({
       label: "Pay Now"
     }))
   ]),
-  styles: import_zod30.z.union([
-    import_zod30.z.object({
-      buttonWidth: import_zod30.z.number().min(10).max(100).default(50)
+  styles: import_zod31.z.union([
+    import_zod31.z.object({
+      buttonWidth: import_zod31.z.number().min(10).max(100).default(50)
     }),
-    import_zod30.z.array(import_zod30.z.never()).transform(() => ({
+    import_zod31.z.array(import_zod31.z.never()).transform(() => ({
       buttonWidth: 50
     }))
   ]),
-  type: import_zod30.z.literal(BlockType.pay_button).default(BlockType.pay_button)
+  type: import_zod31.z.literal(BlockType.pay_button).default(BlockType.pay_button)
 });
-var ProductInformationBlock = import_zod30.z.object({
+var ProductInformationBlock = import_zod31.z.object({
   /** This isn't configurable in the admin-nextjs editor */
-  hideProductImage: import_zod30.z.boolean().optional().default(false),
-  id: import_zod30.z.string().optional().default(() => (0, import_uuid14.v4)()),
-  name: import_zod30.z.string().optional(),
-  type: import_zod30.z.literal(BlockType.product_information).default(BlockType.product_information)
-});
-var SeparatorBlock = import_zod30.z.object({
-  id: import_zod30.z.string().optional().default(() => (0, import_uuid14.v4)()),
-  name: import_zod30.z.string().optional(),
-  type: import_zod30.z.literal(BlockType.separator).default(BlockType.separator)
-});
-var TextBlock = import_zod30.z.object({
-  id: import_zod30.z.string().optional().default(() => (0, import_uuid14.v4)()),
-  name: import_zod30.z.string().optional(),
-  settings: import_zod30.z.object({
-    description: import_zod30.z.union([import_zod30.z.string(), TiptapDocument]).optional().default(
+  hideProductImage: import_zod31.z.boolean().optional().default(false),
+  id: import_zod31.z.string().optional().default(() => (0, import_uuid14.v4)()),
+  name: import_zod31.z.string().optional(),
+  type: import_zod31.z.literal(BlockType.product_information).default(BlockType.product_information)
+});
+var SeparatorBlock = import_zod31.z.object({
+  id: import_zod31.z.string().optional().default(() => (0, import_uuid14.v4)()),
+  name: import_zod31.z.string().optional(),
+  type: import_zod31.z.literal(BlockType.separator).default(BlockType.separator)
+});
+var TextBlock = import_zod31.z.object({
+  id: import_zod31.z.string().optional().default(() => (0, import_uuid14.v4)()),
+  name: import_zod31.z.string().optional(),
+  settings: import_zod31.z.object({
+    description: import_zod31.z.union([import_zod31.z.string(), TiptapDocument]).optional().default(
       "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum."
     ),
     /** This isn't used in the post-purchase offer widget */
     descriptionSize: TextSize.default("medium"),
     horizontalAlignment: TextAlignment2.default("leading"),
-    superTitle: import_zod30.z.union([import_zod30.z.string(), TiptapDocument]).default("Super Title"),
+    superTitle: import_zod31.z.union([import_zod31.z.string(), TiptapDocument]).default("Super Title"),
     /** This isn't used in the post-purchase offer widget */
     superTitleSize: TextSize.default("medium"),
-    title: import_zod30.z.union([import_zod30.z.string(), TiptapDocument]).nullable().default("Lorem ipsum dolor sit amet."),
+    title: import_zod31.z.union([import_zod31.z.string(), TiptapDocument]).nullable().default("Lorem ipsum dolor sit amet."),
     /** This isn't used in the post-purchase offer widget */
     titleSize: TextSize.default("medium")
   }),
-  type: import_zod30.z.literal(BlockType.text).default(BlockType.text)
-});
-var TimerBlock = import_zod30.z.object({
-  id: import_zod30.z.string().optional().default(() => (0, import_uuid14.v4)()),
-  name: import_zod30.z.string().optional(),
-  settings: import_zod30.z.object({
-    durationMinutes: import_zod30.z.number().min(0).default(10),
-    durationSeconds: import_zod30.z.union([import_zod30.z.number().min(0), import_zod30.z.unknown().transform(() => 0)]).default(0),
-    endOffer: import_zod30.z.boolean().default(true),
-    title: import_zod30.z.union([import_zod30.z.string(), TiptapDocument]).default("Hurry \u2014 your special offer ends in:")
+  type: import_zod31.z.literal(BlockType.text).default(BlockType.text)
+});
+var TimerBlock = import_zod31.z.object({
+  id: import_zod31.z.string().optional().default(() => (0, import_uuid14.v4)()),
+  name: import_zod31.z.string().optional(),
+  settings: import_zod31.z.object({
+    durationMinutes: import_zod31.z.number().min(0).default(10),
+    durationSeconds: import_zod31.z.union([import_zod31.z.number().min(0), import_zod31.z.unknown().transform(() => 0)]).default(0),
+    endOffer: import_zod31.z.boolean().default(true),
+    title: import_zod31.z.union([import_zod31.z.string(), TiptapDocument]).default("Hurry \u2014 your special offer ends in:")
   }),
-  styles: import_zod30.z.object({
+  styles: import_zod31.z.object({
     textAlignment: TextAlignment2.default("center"),
-    timerBackgroundColor: import_zod30.z.enum(["info", "warning", "success", "critical"]).default("warning"),
-    timerEmphasized: import_zod30.z.union([import_zod30.z.boolean(), import_zod30.z.unknown().transform(() => true)]).default(true),
+    timerBackgroundColor: import_zod31.z.enum(["info", "warning", "success", "critical"]).default("warning"),
+    timerEmphasized: import_zod31.z.union([import_zod31.z.boolean(), import_zod31.z.unknown().transform(() => true)]).default(true),
     timerSize: TextSize.default("medium"),
-    timerWidth: import_zod30.z.number().min(10).max(100).optional().default(100),
-    titleEmphasized: import_zod30.z.union([import_zod30.z.boolean(), import_zod30.z.unknown().transform(() => true)]).default(false),
+    timerWidth: import_zod31.z.number().min(10).max(100).optional().default(100),
+    titleEmphasized: import_zod31.z.union([import_zod31.z.boolean(), import_zod31.z.unknown().transform(() => true)]).default(false),
     titleSize: TextSize.default("medium")
   }),
-  type: import_zod30.z.literal(BlockType.timer).default(BlockType.timer)
+  type: import_zod31.z.literal(BlockType.timer).default(BlockType.timer)
 });
-var PostPurchaseBlock = import_zod30.z.discriminatedUnion("type", [
+var PostPurchaseBlock = import_zod31.z.discriminatedUnion("type", [
   CalloutBannerBlock,
   ImageBlock,
   ImageContentBlock,
@@ -4007,7 +4029,7 @@ var styledTextRun = (text2, emphasized, size) => ({
 // src/transforms/postPurchase/convertCalloutBlock.ts
 var fields = ["superTitle", "title"];
 var Shell = CalloutBannerBlock.pick({ styles: true }).extend({
-  settings: import_zod31.z.object({ superTitle: import_zod31.z.unknown().optional(), title: import_zod31.z.unknown().optional() })
+  settings: import_zod32.z.object({ superTitle: import_zod32.z.unknown().optional(), title: import_zod32.z.unknown().optional() })
 });
 var convertCalloutBlock = (raw, report) => {
   const omit = (detail) => {
@@ -4042,7 +4064,7 @@ var convertCalloutBlock = (raw, report) => {
 };
 
 // src/transforms/postPurchase/convertImageFrame.ts
-var import_zod32 = require("zod");
+var import_zod33 = require("zod");
 
 // src/transforms/postPurchase/sizeImageSource.ts
 var sizeImageSource = (source2, size) => {
@@ -4054,7 +4076,7 @@ var sizeImageSource = (source2, size) => {
 };
 
 // src/transforms/postPurchase/convertImageFrame.ts
-var Source = import_zod32.z.url().default("https://cdn.shopify.com/s/files/1/0605/0555/5177/files/placeholder.jpg?v=1657762972");
+var Source = import_zod33.z.url().default("https://cdn.shopify.com/s/files/1/0605/0555/5177/files/placeholder.jpg?v=1657762972");
 var DEFAULT_IMAGE_SIZE = 20;
 var convertImageFrame = (raw) => {
   const parsed = ImageBlock.shape.settings.options[0].safeParse(raw);
@@ -4100,7 +4122,7 @@ var convertImageBlock = (raw, report) => {
 };
 
 // src/transforms/postPurchase/convertImageContentBlock.ts
-var import_zod34 = require("zod");
+var import_zod35 = require("zod");
 
 // src/transforms/postPurchase/convertImageContentText.ts
 var fields2 = ["superTitle", "title", "description"];
@@ -4130,7 +4152,7 @@ var convertImageContentText = (settings, report) => {
 };
 
 // src/transforms/postPurchase/imageContentSettings.ts
-var import_zod33 = require("zod");
+var import_zod34 = require("zod");
 var ImageContentSettings = ImageContentBlock.shape.settings.pick({
   descriptionSize: true,
   horizontalAlignment: true,
@@ -4138,17 +4160,17 @@ var ImageContentSettings = ImageContentBlock.shape.settings.pick({
   swapContent: true,
   titleSize: true
 }).extend({
-  alt: import_zod33.z.unknown().optional(),
-  description: import_zod33.z.unknown().optional(),
-  image: import_zod33.z.unknown().optional(),
+  alt: import_zod34.z.unknown().optional(),
+  description: import_zod34.z.unknown().optional(),
+  image: import_zod34.z.unknown().optional(),
   imagePlacement: ImageContentBlock.shape.settings.shape.imagePlacement.unwrap().nullable(),
-  imageSize: ImageContentBlock.shape.settings.shape.imageSize.pipe(import_zod33.z.number().positive()),
-  superTitle: import_zod33.z.unknown().optional(),
-  title: import_zod33.z.unknown().optional()
+  imageSize: ImageContentBlock.shape.settings.shape.imageSize.pipe(import_zod34.z.number().positive()),
+  superTitle: import_zod34.z.unknown().optional(),
+  title: import_zod34.z.unknown().optional()
 });
 
 // src/transforms/postPurchase/convertImageContentBlock.ts
-var Shell2 = import_zod34.z.object({ settings: ImageContentSettings, type: import_zod34.z.literal("image_content") });
+var Shell2 = import_zod35.z.object({ settings: ImageContentSettings, type: import_zod35.z.literal("image_content") });
 var PROPORTIONAL_BREAK_AT = 500;
 var convertImageContentBlock = (raw, report) => {
   const shell = Shell2.safeParse(raw);
@@ -4213,91 +4235,468 @@ var convertPayButtonBlock = (raw, report) => {
   ];
 };
 
-// src/transforms/postPurchase/convertProductInformation.ts
-var convertProductInformation = (raw, report) => {
-  const block = ProductInformationBlock.safeParse(raw);
-  if (!block.success) {
-    report?.({ detail: "Unreadable post-purchase product information", kind: "section" });
-    return [];
-  }
+// src/transforms/postPurchase/productCardControls.ts
+var groupSelector = { sectionType: "variants", selector: "menu", variantMode: "productGroup" };
+var variantSelector = ({ productOptions }) => {
+  if (!productOptions.showVariantSelectors) return [];
+  const single = productOptions.variantSelectorDisplayMode === "single";
   return [
-    CABOffersSection.parse({
-      direction: "grid",
-      sections: [
-        CABLayoutSection.parse({
-          alignment: { horizontal: "center" },
-          sections: [
-            CABLayoutSection.parse({
-              alignment: { horizontal: "center" },
-              direction: "grid",
-              grid: { columns: [250] },
-              sections: [
-                CABImageSection.parse({ altText: "{{productTitle}}", source: "{{productImage}}" })
-              ],
-              width: 90
-            })
-          ]
-        }),
-        CABLayoutSection.parse({
-          sections: [
-            CABTextSection.parse({
-              content: {
-                en: {
-                  content: [
-                    {
-                      content: [
-                        {
-                          marks: [{ attrs: { fontSize: "heading" }, type: "textStyle" }],
-                          text: "{{productTitle}}"
-                        }
-                      ]
-                    }
-                  ]
-                }
-              }
-            }),
-            CABReviewsSection.parse({}),
-            CABTextSection.parse({ content: { en: "{{productDescription}}" } })
-          ]
-        })
-      ],
-      spacing: "extraLoose",
-      wrapping: { breakAt: 500, maxPerLine: block.data.hideProductImage ? 1 : 2 }
-    })
+    {
+      hideOutOfStockVariants: single || productOptions.hideOutOfStockVariants,
+      sectionType: "variants",
+      selector: "menu",
+      variantMode: single ? "single" : "multiple"
+    }
   ];
 };
+var quantity = ({ language: language3, quantityInputs: quantityInputs2 }) => quantityInputs2.enabled ? [
+  quantitySection({
+    maxValue: quantityInputs2.maxValue,
+    minValue: quantityInputs2.minValue,
+    name: language3.global.quantity.trim()
+  })
+] : [];
+var productCardControls = (settings) => [
+  ...subscriptionToggle(settings.productType),
+  groupSelector,
+  ...variantSelector(settings),
+  ...quantity(settings)
+];
 
-// src/transforms/postPurchase/convertSeparatorBlock.ts
-var convertSeparatorBlock = (raw, report) => {
-  if (!SeparatorBlock.safeParse(raw).success) {
-    report?.({ detail: "Unreadable post-purchase separator", kind: "section" });
-    return [];
-  }
-  return [CABSeparatorSection.parse({})];
+// src/transforms/postPurchase/productCardRows.ts
+var styledCopy = (text2, look) => ({
+  content: [{ content: [{ marks: [{ attrs: look, type: "textStyle" }], text: text2, type: "text" }], type: "paragraph" }],
+  type: "doc"
+});
+var merchantLabel = (value, fallback) => localizedContent({ en: fallback }, value);
+var boundText = (variable, content) => ({
+  content,
+  sectionType: "text",
+  visibility: shownWhile(variable)
+});
+var earnedRow = ({ after, columns, label: label2, look, spacing, token, variable }) => {
+  const styled2 = (text2) => look ? styledCopy(text2, look) : text2;
+  const value = earnedText(variable, styled2(token));
+  return {
+    direction: "grid",
+    grid: { columns, rows: ["auto"] },
+    sections: [
+      boundText(variable, look ? { en: styled2(String(label2.en)) } : label2),
+      value,
+      ...after === void 0 ? [] : [boundText(variable, { en: styled2(String(after)) })]
+    ],
+    sectionType: "layout",
+    ...spacing && { spacing }
+  };
 };
+var earnedVariables = (names) => names.map((name) => ({ defaultValue: false, name }));
 
-// src/transforms/postPurchase/convertTextBlock.ts
-var import_zod35 = require("zod");
-var fields3 = ["superTitle", "title", "description"];
-var styles = {
-  description: [{ attrs: { color: "base", fontSize: "small" }, type: "textStyle" }],
-  superTitle: [{ attrs: { color: "subdued", fontSize: "small" }, type: "textStyle" }],
-  title: [{ type: "bold" }, { attrs: { color: "base", fontSize: "large" }, type: "textStyle" }]
-};
-var settingsSchema = TextBlock.shape.settings;
-var Shell3 = import_zod35.z.object({
-  settings: settingsSchema.pick({ horizontalAlignment: true }).extend({
-    description: import_zod35.z.unknown().optional(),
-    superTitle: import_zod35.z.unknown().optional(),
-    title: import_zod35.z.unknown().optional()
-  }),
-  type: import_zod35.z.literal("text")
-});
-var convertTextBlock = (raw, report) => {
-  const shell = Shell3.safeParse(raw);
-  if (!shell.success) {
-    report?.({ detail: "Unreadable post-purchase text block", kind: "section" });
-    return [];
+// src/transforms/postPurchase/productCardSettings.ts
+var import_es_toolkit6 = require("es-toolkit");
+var import_zod38 = require("zod");
+
+// src/schema/widgets/post-purchase-offer/postPurchaseSettings.ts
+var import_zod37 = require("zod");
+
+// src/schema/widgets/post-purchase-offer/common.ts
+var import_compat5 = require("es-toolkit/compat");
+var import_zod36 = require("zod");
+var strictNumber = import_zod36.z.union([
+  import_zod36.z.number(),
+  import_zod36.z.string().transform((value) => (0, import_compat5.toNumber)((0, import_compat5.replace)((0, import_compat5.toString)(value), /[^0-9.]/g, "")) || 0),
+  import_zod36.z.unknown().transform(() => 0)
+]);
+
+// src/schema/widgets/post-purchase-offer/postPurchaseSettings.ts
+var PostPurchaseSettings = import_zod37.z.object({
+  advance: import_zod37.z.object({ removePartialOrder: import_zod37.z.boolean().default(true) }).optional().default(() => ({ removePartialOrder: true })),
+  blocks: import_zod37.z.union([import_zod37.z.array(PostPurchaseBlock), import_zod37.z.unknown().transform(() => [])]).default(() => [
+    PostPurchaseBlock.parse({ settings: {}, styles: {}, type: BlockType.timer }),
+    PostPurchaseBlock.parse({ settings: {}, styles: {}, type: BlockType.callout_banner }),
+    PostPurchaseBlock.parse({ type: BlockType.product_information })
+  ]),
+  columnLayout: import_zod37.z.boolean().optional(),
+  discount: import_zod37.z.object({
+    amount: strictNumber.default(30),
+    shouldShowSavingText: import_zod37.z.boolean().optional().default(true),
+    type: import_zod37.z.enum(["none", "fixed_amount", "percentage"]).default("none")
+  }),
+  discountedFrom: import_zod37.z.enum(["price", "compare_at_price"]).optional().default("price"),
+  endpoint: import_zod37.z.string().optional(),
+  integrations: import_zod37.z.object({
+    judgeme: import_zod37.z.boolean().default(false),
+    junip: import_zod37.z.boolean().optional().default(false),
+    klaviyo: import_zod37.z.boolean().default(false),
+    loox: import_zod37.z.boolean().default(false),
+    okendo: import_zod37.z.boolean().default(false),
+    opinew: import_zod37.z.boolean().optional().default(false),
+    reviewsio: import_zod37.z.boolean().optional().default(false),
+    stamped: import_zod37.z.boolean().default(false),
+    yotpo: import_zod37.z.boolean().default(false)
+  }),
+  key: import_zod37.z.string().optional(),
+  language: import_zod37.z.object({
+    description: import_zod37.z.union([import_zod37.z.string(), import_zod37.z.unknown().transform(() => "")]).default(""),
+    descriptionEnabled: import_zod37.z.boolean().optional().default(false),
+    descriptionRte: import_zod37.z.object({
+      content: import_zod37.z.array(import_zod37.z.unknown()),
+      type: import_zod37.z.string()
+    }).optional(),
+    descriptionSpacing: import_zod37.z.enum(["none", "xtight", "tight", "default", "loose", "xloose"]).optional(),
+    displayCtaPrice: import_zod37.z.boolean().default(true),
+    global: import_zod37.z.object({
+      declineAll: import_zod37.z.string().optional().default("Decline All"),
+      declineThisOffer: import_zod37.z.string().default("Decline this offer"),
+      free: import_zod37.z.string().optional().default("Free"),
+      notAvailable: import_zod37.z.string().optional().default("Not available"),
+      payNow: import_zod37.z.string().default("Pay Now"),
+      payNowUpgradeToSubscription: import_zod37.z.string().optional().default("Upgrade to Subscription"),
+      quantity: import_zod37.z.string().default("Quantity"),
+      /** This isn't configurable in the admin-nextjs editor */
+      recurringShipping: import_zod37.z.string().optional().default("Recurring shipping"),
+      recurringSubtotal: import_zod37.z.string().default("Recurring subtotal"),
+      reviewsPlural: import_zod37.z.string().optional().default("Reviews"),
+      reviewsSingular: import_zod37.z.string().optional().default("Review"),
+      save: import_zod37.z.union([import_zod37.z.string(), import_zod37.z.unknown().transform(() => "Save")]).optional().default("Save"),
+      shipping: import_zod37.z.string().default("Shipping"),
+      subscriptionOption: import_zod37.z.string().optional().default("Subscribe and Save"),
+      subtotal: import_zod37.z.string().default("Subtotal"),
+      taxes: import_zod37.z.string().default("Taxes"),
+      total: import_zod37.z.string().default("Total")
+    }).optional().default(() => ({
+      declineAll: "Decline All",
+      declineThisOffer: "Decline this offer",
+      free: "Free",
+      notAvailable: "Not available",
+      payNow: "Pay Now",
+      payNowUpgradeToSubscription: "Upgrade to Subscription",
+      quantity: "Quantity",
+      /** This isn't configurable in the admin-nextjs editor */
+      recurringShipping: "Recurring shipping",
+      recurringSubtotal: "Recurring subtotal",
+      reviewsPlural: "Reviews",
+      reviewsSingular: "Review",
+      save: "Save",
+      shipping: "Shipping",
+      subscriptionOption: "Subscribe and Save",
+      subtotal: "Subtotal",
+      taxes: "Taxes",
+      total: "Total"
+    })),
+    globalTranslation: import_zod37.z.string().optional().default("english")
+  }),
+  metafields: import_zod37.z.boolean().default(false),
+  /** This isn't configurable in the admin-nextjs editor */
+  offer: import_zod37.z.object({
+    count: import_zod37.z.number().default(1)
+  }),
+  offersLayout: import_zod37.z.object({
+    itemsPerPage: import_zod37.z.number().optional(),
+    type: import_zod37.z.enum(["list", "grid", "carousel"]).default("list")
+  }).optional().default({
+    type: "list"
+  }),
+  /** This isn't configurable in the admin-nextjs editor */
+  previewMode: import_zod37.z.boolean().default(false),
+  productLimit: import_zod37.z.number().optional().default(1),
+  productOptions: import_zod37.z.object({
+    /** This isn't configurable in the admin-nextjs editor */
+    hideOutOfStockVariants: import_zod37.z.boolean().optional().default(false),
+    matchVariant: import_zod37.z.boolean().optional().default(true),
+    showDeclineAll: import_zod37.z.enum(["above", "below", "both", "none"]).optional(),
+    showShipping: import_zod37.z.boolean().optional().default(true),
+    showSubtotal: import_zod37.z.boolean().optional().default(true),
+    showTaxes: import_zod37.z.boolean().optional().default(true),
+    showTotal: import_zod37.z.boolean().optional().default(true),
+    showVariantSelectors: import_zod37.z.boolean().optional().default(true),
+    variantSelectorDisplayMode: import_zod37.z.enum(["separate", "single"]).optional().default("separate")
+  }),
+  productType: import_zod37.z.union([import_zod37.z.enum(["one-time", "subscription", "both"]), import_zod37.z.literal("").transform(() => "one-time")]).default("one-time"),
+  productTypeSelector: import_zod37.z.enum(["dropdown", "radio"]).optional().default("radio"),
+  quantityInputs: import_zod37.z.object({
+    defaultQuantity: import_zod37.z.union([import_zod37.z.number(), import_zod37.z.null().transform(() => 1)]).default(1),
+    enabled: import_zod37.z.boolean().default(true),
+    maxValue: import_zod37.z.union([import_zod37.z.number(), import_zod37.z.null().transform(() => 15)]).default(15),
+    minValue: import_zod37.z.union([import_zod37.z.number().min(0), import_zod37.z.unknown().transform(() => 0)]).default(1)
+  }),
+  shipping: import_zod37.z.object({
+    amount: strictNumber.default(10),
+    /** This isn't configurable in the admin-nextjs editor */
+    enabled: import_zod37.z.boolean().default(true),
+    title: import_zod37.z.string().optional().default("Shipping Fees"),
+    type: import_zod37.z.enum(["free", "fixed_amount"]).default("free")
+  }),
+  styles: import_zod37.z.object({
+    starColor: import_zod37.z.string().optional().default("#fadb14"),
+    starSize: import_zod37.z.union([import_zod37.z.enum(["small", "medium", "large"]), import_zod37.z.unknown().transform(() => "large")]).optional().default("large"),
+    starStrokeColor: import_zod37.z.string().optional().default("#fadb14"),
+    strokeWidth: import_zod37.z.string().optional().default("1")
+  }).optional(),
+  subImages: import_zod37.z.number().nullish().default(8),
+  subscription: import_zod37.z.object({
+    discount: import_zod37.z.object({
+      amount: strictNumber.default(30),
+      shouldShowSavingText: import_zod37.z.boolean().optional().default(true),
+      type: import_zod37.z.enum(["none", "fixed_amount", "percentage"]).default("none")
+    }),
+    shipping: import_zod37.z.object({
+      amount: strictNumber.default(1),
+      /** This isn't configurable in the admin-nextjs editor */
+      enabled: import_zod37.z.boolean().default(true),
+      /** This isn't configurable in the admin-nextjs editor */
+      recurringAmount: strictNumber.default(2),
+      shippingTitle: import_zod37.z.string().default("Shipping Fees"),
+      type: import_zod37.z.enum(["free", "fixed_amount"]).default("free")
+    })
+  }).optional().default({
+    discount: {
+      amount: 30,
+      shouldShowSavingText: true,
+      type: "none"
+    },
+    shipping: {
+      amount: 1,
+      /** This isn't configurable in the admin-nextjs editor */
+      enabled: true,
+      /** This isn't configurable in the admin-nextjs editor */
+      recurringAmount: 2,
+      shippingTitle: "Shipping Fees",
+      type: "free"
+    }
+  }),
+  subscriptionIsDefault: import_zod37.z.boolean().optional(),
+  /** This isn't configurable in the admin-nextjs editor */
+  template: import_zod37.z.string().optional().default(""),
+  type: import_zod37.z.literal("shopify_post_purchase_extension").default("shopify_post_purchase_extension"),
+  upgradeToSubscription: import_zod37.z.object({
+    acceptButtonText: import_zod37.z.string().optional().default("Upgrade"),
+    allow: import_zod37.z.boolean().optional().default(false),
+    emailRefundNotice: import_zod37.z.boolean().optional().default(false),
+    errorBannerText: import_zod37.z.string().optional().default("This subscription cannot be added - limit one per order")
+  }).optional().default(() => ({
+    acceptButtonText: "Upgrade",
+    allow: false,
+    emailRefundNotice: false,
+    errorBannerText: "This subscription cannot be added - limit one per order"
+  }))
+});
+
+// src/transforms/postPurchase/productCardSettings.ts
+var { shape } = PostPurchaseSettings;
+var Labels = import_zod38.z.object(
+  (0, import_es_toolkit6.mapValues)(shape.language.shape.global.unwrap().unwrap().shape, (label2) => label2.catch(() => label2.parse(void 0)))
+);
+var Language = import_zod38.z.object({ global: Labels.catch(() => Labels.parse({})) });
+var Fields = import_zod38.z.object({
+  discount: shape.discount.catch(() => shape.discount.parse({})),
+  language: Language.catch(() => Language.parse({})),
+  productOptions: shape.productOptions.catch(() => shape.productOptions.parse({})),
+  productType: shape.productType.catch("one-time"),
+  quantityInputs: shape.quantityInputs.catch(() => shape.quantityInputs.parse({})),
+  subImages: shape.subImages.catch(null),
+  subscription: shape.subscription.catch(() => shape.subscription.parse(void 0)),
+  upgradeToSubscription: shape.upgradeToSubscription.catch(() => shape.upgradeToSubscription.parse(void 0))
+});
+var ProductCardSettings = Fields.catch(() => Fields.parse({}));
+var sellsSubscription = ({ productType, upgradeToSubscription }) => productType !== "one-time" || upgradeToSubscription.allow;
+
+// src/transforms/postPurchase/productCardCosts.ts
+var COST_ROWS = [
+  ["showSubtotal", "subtotal", "Subtotal", "hasSubtotal"],
+  ["showShipping", "shipping", "Shipping", "hasShipping"],
+  ["showTaxes", "taxes", "Taxes", "hasTaxes"],
+  ["showTotal", "total", "Total", "hasTotal"]
+];
+var costRows = ({ language: language3, productOptions }) => {
+  const rows = COST_ROWS.filter(([show]) => productOptions[show]);
+  if (!rows.length) return [];
+  return [
+    {
+      direction: "rows",
+      name: "costs",
+      sections: rows.map(
+        ([, key, fallback, variable]) => earnedRow({
+          columns: ["fill", "auto"],
+          label: merchantLabel(language3.global[key], fallback),
+          token: `{{${key}}}`,
+          variable
+        })
+      ),
+      sectionType: "layout",
+      spacing: "tight",
+      variables: earnedVariables(rows.map(([, , , variable]) => variable))
+    }
+  ];
+};
+var HAS_RECURRING_TOTAL = "hasRecurringTotal";
+var HAS_RECURRING_SHIPPING = "hasRecurringShipping";
+var small = { color: "subdued", fontSize: "small" };
+var FOOTNOTES = ["Doesn't include tax, duties, or any applicable discounts.", "Auto-renews, skip or cancel anytime"];
+var recurringSummary = (settings) => {
+  if (!sellsSubscription(settings)) return [];
+  const { global: global2 } = settings.language;
+  return [
+    {
+      direction: "rows",
+      name: "recurring",
+      sections: [
+        earnedRow({
+          after: "on every Delivery",
+          columns: ["fill", "auto", "auto"],
+          label: merchantLabel(global2.recurringSubtotal, "Recurring subtotal"),
+          spacing: "extraTight",
+          token: "{{recurringTotal}}",
+          variable: HAS_RECURRING_TOTAL
+        }),
+        earnedRow({
+          after: "(included)",
+          columns: ["auto", "auto", "auto"],
+          label: { en: `${merchantLabel(global2.recurringShipping, "Recurring shipping").en}:` },
+          look: small,
+          spacing: "extraTight",
+          token: "{{recurringShipping}}",
+          variable: HAS_RECURRING_SHIPPING
+        }),
+        ...FOOTNOTES.map((text2) => ({
+          content: { en: styledCopy(text2, small) },
+          sectionType: "text",
+          visibility: shownWhile(HAS_RECURRING_TOTAL)
+        }))
+      ],
+      sectionType: "layout",
+      spacing: "tight",
+      variables: earnedVariables([HAS_RECURRING_TOTAL, HAS_RECURRING_SHIPPING])
+    }
+  ];
+};
+var productCardCosts = (settings) => [
+  ...costRows(settings),
+  ...recurringSummary(settings)
+];
+
+// src/transforms/postPurchase/productCardPricing.ts
+var import_compat6 = require("es-toolkit/compat");
+var HAS_SAVING = "hasSaving";
+var savingLine = (settings) => {
+  const subscriptionSaving = sellsSubscription(settings) && settings.subscription.discount.shouldShowSavingText;
+  if (!settings.discount.shouldShowSavingText && !subscriptionSaving) return [];
+  return [
+    {
+      ...earnedRow({
+        columns: ["auto", "auto"],
+        label: merchantLabel((0, import_compat6.capitalize)(settings.language.global.save), "Save"),
+        look: { color: "success" },
+        spacing: "extraTight",
+        token: "{{variantSaving}}",
+        variable: HAS_SAVING
+      }),
+      name: "saving",
+      variables: earnedVariables([HAS_SAVING])
+    }
+  ];
+};
+var productCardPricing = (settings) => [
+  priceText(),
+  ...savingLine(settings)
+];
+
+// src/transforms/postPurchase/convertProductInformation.ts
+var thumbnails = ({ subImages }) => {
+  const limit = Math.floor(subImages ?? 0);
+  return limit >= 1 ? { thumbnails: { limit } } : {};
+};
+var convertProductInformation = (raw, report, widgetSettings) => {
+  const block = ProductInformationBlock.safeParse(raw);
+  if (!block.success) {
+    report?.({ detail: "Unreadable post-purchase product information", kind: "section" });
+    return [];
+  }
+  const settings = ProductCardSettings.parse(widgetSettings ?? {});
+  return [
+    CABOffersSection.parse({
+      direction: "grid",
+      sections: [
+        CABLayoutSection.parse({
+          alignment: { horizontal: "center" },
+          sections: [
+            CABLayoutSection.parse({
+              alignment: { horizontal: "center" },
+              direction: "grid",
+              grid: { columns: [250] },
+              sections: [
+                CABImageSection.parse({
+                  altText: "{{productTitle}}",
+                  source: "{{productImage}}",
+                  ...thumbnails(settings)
+                })
+              ],
+              width: 90
+            })
+          ]
+        }),
+        CABLayoutSection.parse({
+          sections: [
+            CABTextSection.parse({
+              content: {
+                en: {
+                  content: [
+                    {
+                      content: [
+                        {
+                          marks: [{ attrs: { fontSize: "heading" }, type: "textStyle" }],
+                          text: "{{productTitle}}"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              }
+            }),
+            ...productCardPricing(settings),
+            CABReviewsSection.parse({}),
+            CABTextSection.parse({ content: { en: "{{productDescription}}" } }),
+            ...productCardControls(settings),
+            ...productCardCosts(settings)
+          ]
+        })
+      ],
+      spacing: "extraLoose",
+      wrapping: { breakAt: 500, maxPerLine: block.data.hideProductImage ? 1 : 2 }
+    })
+  ];
+};
+
+// src/transforms/postPurchase/convertSeparatorBlock.ts
+var convertSeparatorBlock = (raw, report) => {
+  if (!SeparatorBlock.safeParse(raw).success) {
+    report?.({ detail: "Unreadable post-purchase separator", kind: "section" });
+    return [];
+  }
+  return [CABSeparatorSection.parse({})];
+};
+
+// src/transforms/postPurchase/convertTextBlock.ts
+var import_zod39 = require("zod");
+var fields3 = ["superTitle", "title", "description"];
+var styles = {
+  description: [{ attrs: { color: "base", fontSize: "small" }, type: "textStyle" }],
+  superTitle: [{ attrs: { color: "subdued", fontSize: "small" }, type: "textStyle" }],
+  title: [{ type: "bold" }, { attrs: { color: "base", fontSize: "large" }, type: "textStyle" }]
+};
+var settingsSchema = TextBlock.shape.settings;
+var Shell3 = import_zod39.z.object({
+  settings: settingsSchema.pick({ horizontalAlignment: true }).extend({
+    description: import_zod39.z.unknown().optional(),
+    superTitle: import_zod39.z.unknown().optional(),
+    title: import_zod39.z.unknown().optional()
+  }),
+  type: import_zod39.z.literal("text")
+});
+var convertTextBlock = (raw, report) => {
+  const shell = Shell3.safeParse(raw);
+  if (!shell.success) {
+    report?.({ detail: "Unreadable post-purchase text block", kind: "section" });
+    return [];
   }
   const values2 = fields3.map((field) => ({
     field,
@@ -4363,11 +4762,11 @@ var convertTimerBlock = (raw, report) => {
 };
 
 // src/transforms/postPurchase/convertMessagePreview.ts
-var MessageWidget = import_zod36.z.object({
-  blocks: import_zod36.z.array(import_zod36.z.unknown()).min(1),
-  type: import_zod36.z.literal(WidgetType.shopify_post_purchase_extension)
+var MessageWidget = import_zod40.z.object({
+  blocks: import_zod40.z.array(import_zod40.z.unknown()).min(1),
+  type: import_zod40.z.literal(WidgetType.shopify_post_purchase_extension)
 });
-var BlockType2 = import_zod36.z.object({ type: import_zod36.z.string() });
+var BlockType2 = import_zod40.z.object({ type: import_zod40.z.string() });
 var converters = {
   callout_banner: convertCalloutBlock,
   image: convertImageBlock,
@@ -4388,7 +4787,7 @@ var convertMessagePreview = (id, settings, report) => {
       const type = BlockType2.safeParse(block);
       const kind = type.success ? type.data.type : void 0;
       const convert2 = kind && Object.hasOwn(converters, kind) ? converters[kind] : void 0;
-      if (convert2) return convert2(block, report);
+      if (convert2) return convert2(block, report, settings);
       report?.({
         detail: kind ? `Unsupported post-purchase block type: ${kind}` : "Unreadable post-purchase block: missing type",
         kind: "section"
@@ -4827,14 +5226,14 @@ function serialize(obj) {
 var encodeAttributes = (pairs = []) => JSON.stringify(Object.fromEntries(pairs.map(({ key, value }) => [key, value ?? ""])));
 var buildEngineParams = (input, key) => {
   const { cart, customerId, filterInputs, integrations, limit, productType, shop, visitorId } = input;
-  const items = cart.items.map(({ productId: productId2, properties, quantity: quantity2, subscriptionId, variantId }) => ({
+  const items = cart.items.map(({ productId: productId2, properties, quantity: quantity3, subscriptionId, variantId }) => ({
     product_id: productId2,
     properties: encodeAttributes(properties),
-    quantity: quantity2,
+    quantity: quantity3,
     ...subscriptionId && { subscription_id: subscriptionId },
     variant_id: variantId
   }));
-  const itemCount = cart.items.reduce((total, { quantity: quantity2 }) => total + quantity2, 0);
+  const itemCount = cart.items.reduce((total, { quantity: quantity3 }) => total + quantity3, 0);
   const subtotal = shopSubtotalCents(cart);
   return {
     cart: {
@@ -4879,7 +5278,7 @@ var reportUnreadableVerdict = (metadata, report) => {
   if (RuleVerdict.safeParse(metadata).success || isDefinitiveRuleAnswer(metadata)) return;
   report?.({ detail: "rule verdict lacks readable custom.shouldShow", kind: "ruleVerdict" });
 };
-var dedupeById = (products) => (0, import_es_toolkit6.uniqBy)(products, (product) => product.id);
+var dedupeById = (products) => (0, import_es_toolkit7.uniqBy)(products, (product) => product.id);
 var MAX_REQUEST_LINE_BYTES = 32e3;
 var requestLineBytes = (path, search) => new TextEncoder().encode(`GET ${path}?${search} HTTP/1.1`).length;
 var fetchDataSourceResults = async (input, ctx) => {
@@ -4915,43 +5314,43 @@ var fetchDataSourceResults = async (input, ctx) => {
 };
 
 // src/server/adsEngine.ts
-var import_zod37 = require("zod");
+var import_zod41 = require("zod");
 var SUPPLY_KEY = { production: "AQF5RKLR", staging: "Z56LQ7PS" };
 var OFFER_LIMIT = 4;
 var SUPPORTED_COUNTRIES = /* @__PURE__ */ new Set(["US", "CA", "GB"]);
 var MAX_TRANSACTION_ITEMS = 50;
 var TEST_CUSTOMER_EMAIL = "test@rebuyengine.com";
-var transactionItems = (input) => (input.transactionItems?.map(({ id, priceCents, quantity: quantity2, title, type }) => ({
+var transactionItems = (input) => (input.transactionItems?.map(({ id, priceCents, quantity: quantity3, title, type }) => ({
   id,
   price_cents: priceCents,
-  quantity: quantity2,
+  quantity: quantity3,
   title,
   type
-})) ?? input.cart.items.map(({ productId: productId2, quantity: quantity2 }) => ({ id: productId2, quantity: quantity2 }))).slice(0, MAX_TRANSACTION_ITEMS);
-var AdsEngineOffer = import_zod37.z.object({
+})) ?? input.cart.items.map(({ productId: productId2, quantity: quantity3 }) => ({ id: productId2, quantity: quantity3 }))).slice(0, MAX_TRANSACTION_ITEMS);
+var AdsEngineOffer = import_zod41.z.object({
   /** Pill-style value prop ("Get $45 Cashback"). Carried through the parse; the card does not render it yet (REB-24429 — pill design pending). */
-  callout: import_zod37.z.string().catch(""),
-  click_url: import_zod37.z.string(),
-  cta: import_zod37.z.string(),
+  callout: import_zod41.z.string().catch(""),
+  click_url: import_zod41.z.string(),
+  cta: import_zod41.z.string(),
   /** `omitempty` on the ad server — a bid without it must not fail the parse and drop the whole batch (composeOffer falls back to 'No Thanks'). */
-  decline_cta: import_zod37.z.string().catch(""),
-  decline_url: import_zod37.z.string(),
-  description: import_zod37.z.string(),
+  decline_cta: import_zod41.z.string().catch(""),
+  decline_url: import_zod41.z.string(),
+  description: import_zod41.z.string(),
   /** Short legal disclosure (FDIC / auto-renewal / FTC-affiliation lines). Rendered subdued under the CTAs. */
-  disclaimer: import_zod37.z.string().catch(""),
+  disclaimer: import_zod41.z.string().catch(""),
   /** Long legal text behind the disclosure toggle in the composed card (REB-24429). */
-  extended_disclaimer: import_zod37.z.string().catch(""),
-  headline: import_zod37.z.string(),
-  id: import_zod37.z.string(),
+  extended_disclaimer: import_zod41.z.string().catch(""),
+  headline: import_zod41.z.string(),
+  id: import_zod41.z.string(),
   /** Advertiser-supplied image alt; the composed card falls back to the stripped headline when empty. */
-  image_alt: import_zod37.z.string().catch(""),
-  image_url: import_zod37.z.string().optional(),
+  image_alt: import_zod41.z.string().catch(""),
+  image_url: import_zod41.z.string().optional(),
   /** The serving network's own privacy page (Falcon, REB-24744); the card prefers it over the widget setting. A bad value drops only this field, never the offer. */
-  privacy_url: import_zod37.z.string().optional().catch(void 0),
-  view_url: import_zod37.z.string()
+  privacy_url: import_zod41.z.string().optional().catch(void 0),
+  view_url: import_zod41.z.string()
 });
-var AdsEngineResponse = import_zod37.z.object({
-  offers: import_zod37.z.array(import_zod37.z.unknown()).default([]).transform(
+var AdsEngineResponse = import_zod41.z.object({
+  offers: import_zod41.z.array(import_zod41.z.unknown()).default([]).transform(
     (offers) => offers.flatMap((offer) => {
       const result = AdsEngineOffer.safeParse(offer);
       return result.success ? [result.data] : [];
@@ -4963,8 +5362,8 @@ var AdsEngineResponse = import_zod37.z.object({
    * offers-testing fixture on a test store forces it, REB-24467). Both optional: an older engine or a
    * non-JSON body must not fail the parse and drop the offers.
    */
-  request_id: import_zod37.z.string().optional().catch(void 0),
-  testing: import_zod37.z.boolean().optional().catch(void 0)
+  request_id: import_zod41.z.string().optional().catch(void 0),
+  testing: import_zod41.z.boolean().optional().catch(void 0)
 });
 var adsHost = (host) => `offers.${host}`;
 var isTestingRequest = (input, isProduction) => !isProduction || !!input.testing || input.customerEmail?.toLowerCase() === TEST_CUSTOMER_EMAIL;
@@ -5416,13 +5815,13 @@ var convertWidgetSettings = async (input, ctx) => {
 };
 
 // src/server/giftWidgets.ts
-var import_zod38 = require("zod");
-var SettingsNumber = import_zod38.z.union([
-  import_zod38.z.number(),
-  import_zod38.z.string().trim().regex(/^-?\d+(\.\d+)?$/)
-]).pipe(import_zod38.z.coerce.number());
-var SgwpMilestoneSchema = import_zod38.z.object({
-  selectable_product_quantity: SettingsNumber.pipe(import_zod38.z.number().int().nonnegative()),
+var import_zod42 = require("zod");
+var SettingsNumber = import_zod42.z.union([
+  import_zod42.z.number(),
+  import_zod42.z.string().trim().regex(/^-?\d+(\.\d+)?$/)
+]).pipe(import_zod42.z.coerce.number());
+var SgwpMilestoneSchema = import_zod42.z.object({
+  selectable_product_quantity: SettingsNumber.pipe(import_zod42.z.number().int().nonnegative()),
   unlock_price: SettingsNumber
 });
 var fetchGiftWidgetSettings = async (widgetId, shop, ctx) => unwrapData(await ctx.fetchUpstream("/api/v1/widgets/settings", { id: String(widgetId), shop }, { host: ctx.host }));
@@ -5433,7 +5832,7 @@ var readDataSourcePath = (settings) => {
 var readMilestones = (settings, report) => {
   const raw = settings && typeof settings === "object" ? settings.milestones : void 0;
   if (raw == null) return [];
-  const parsed = import_zod38.z.array(SgwpMilestoneSchema).safeParse(raw);
+  const parsed = import_zod42.z.array(SgwpMilestoneSchema).safeParse(raw);
   if (parsed.success) return parsed.data;
   report?.({
     detail: [
@@ -5539,25 +5938,25 @@ var validateGifts = async (input, ctx) => {
   const [remove, adjust] = await Promise.all([validateGwpGifts(input, ctx), validateSelectableGifts(input, ctx)]);
   const removed = new Set(remove);
   const targets = /* @__PURE__ */ new Map();
-  for (const { lineId, quantity: quantity2 } of adjust) {
+  for (const { lineId, quantity: quantity3 } of adjust) {
     if (removed.has(lineId)) continue;
-    targets.set(lineId, Math.min(quantity2, targets.get(lineId) ?? quantity2));
+    targets.set(lineId, Math.min(quantity3, targets.get(lineId) ?? quantity3));
   }
-  return { adjust: [...targets].map(([lineId, quantity2]) => ({ lineId, quantity: quantity2 })), remove: [...removed] };
+  return { adjust: [...targets].map(([lineId, quantity3]) => ({ lineId, quantity: quantity3 })), remove: [...removed] };
 };
 
 // src/server/normalizePostPurchaseProduct.ts
-var import_compat6 = require("es-toolkit/compat");
-var import_zod43 = require("zod");
+var import_compat7 = require("es-toolkit/compat");
+var import_zod45 = require("zod");
 
 // src/schema/postPurchaseProductSettings.ts
-var import_zod42 = require("zod");
+var import_zod44 = require("zod");
 
 // src/schema/postPurchaseProductSource.ts
-var import_zod39 = require("zod");
-var PostPurchaseAmount = import_zod39.z.string().regex(/^\d+(?:\.\d+)?$/).refine((value) => Number.isFinite(Number(value)));
-var PostPurchaseProductId = import_zod39.z.number().int().positive();
-var PostPurchaseVariantId = import_zod39.z.number().int().positive();
+var import_zod43 = require("zod");
+var PostPurchaseAmount = import_zod43.z.string().regex(/^\d+(?:\.\d+)?$/).refine((value) => Number.isFinite(Number(value)));
+var PostPurchaseProductId = import_zod43.z.number().int().positive();
+var PostPurchaseVariantId = import_zod43.z.number().int().positive();
 var ProductBase = OfferProduct.pick({ description: true, id: true, image: true, title: true }).extend({
   description: OfferProduct.shape.description.nullable(),
   id: PostPurchaseProductId
@@ -5565,235 +5964,49 @@ var ProductBase = OfferProduct.pick({ description: true, id: true, image: true,
 var SourceVariant = OfferProduct.shape.variants.element.pick({ id: true, title: true }).extend({
   compareAtPrice: PostPurchaseAmount.nullable(),
   id: PostPurchaseVariantId,
-  imageId: import_zod39.z.number().int().nonnegative().nullish(),
-  inventoryManagement: import_zod39.z.string().nullable(),
-  inventoryPolicy: import_zod39.z.string(),
-  inventoryQuantity: import_zod39.z.number(),
-  option1: import_zod39.z.unknown().optional(),
-  option2: import_zod39.z.unknown().optional(),
-  option3: import_zod39.z.unknown().optional(),
+  imageId: import_zod43.z.number().int().nonnegative().nullish(),
+  inventoryManagement: import_zod43.z.string().nullable(),
+  inventoryPolicy: import_zod43.z.string(),
+  inventoryQuantity: import_zod43.z.number(),
+  option1: import_zod43.z.unknown().optional(),
+  option2: import_zod43.z.unknown().optional(),
+  option3: import_zod43.z.unknown().optional(),
   price: PostPurchaseAmount,
-  productId: PostPurchaseProductId,
-  sellingPlanAllocations: import_zod39.z.unknown().optional()
-});
-var Product2 = ProductBase.extend({
-  images: import_zod39.z.array(
-    import_zod39.z.object({ alt: import_zod39.z.string().optional().catch(void 0), id: import_zod39.z.number().int().positive(), src: import_zod39.z.string() })
-  ).nullish(),
-  metadata: import_zod39.z.object({
-    productQuantity: import_zod39.z.union([
-      import_zod39.z.number().int().positive(),
-      import_zod39.z.string().regex(/^[1-9]\d*$/).transform(Number)
-    ]).optional()
-  }).optional(),
-  metafields: import_zod39.z.unknown().optional(),
-  options: import_zod39.z.unknown().optional(),
-  productGroupVariants: import_zod39.z.array(import_zod39.z.unknown()).default([]),
-  selectedVariant: import_zod39.z.unknown().optional(),
-  sellingPlanGroups: import_zod39.z.array(
-    OfferProduct.shape.sellingPlanGroups.unwrap().element.extend({
-      discountAmount: import_zod39.z.unknown().optional(),
-      discountType: import_zod39.z.unknown().optional(),
-      id: import_zod39.z.unknown().optional(),
-      requiresSellingPlan: import_zod39.z.boolean().default(false),
-      sellingPlans: import_zod39.z.unknown().optional()
-    })
-  ).default([]),
-  variants: import_zod39.z.array(SourceVariant)
-});
-var PostPurchaseProductSource = import_zod39.z.object({
-  data: import_zod39.z.array(Product2),
-  metadata: import_zod39.z.object({ widget: import_zod39.z.record(import_zod39.z.string(), import_zod39.z.unknown()).default({}) }).default({ widget: {} })
-});
-
-// src/schema/widgets/post-purchase-offer/postPurchaseSettings.ts
-var import_zod41 = require("zod");
-
-// src/schema/widgets/post-purchase-offer/common.ts
-var import_compat5 = require("es-toolkit/compat");
-var import_zod40 = require("zod");
-var strictNumber = import_zod40.z.union([
-  import_zod40.z.number(),
-  import_zod40.z.string().transform((value) => (0, import_compat5.toNumber)((0, import_compat5.replace)((0, import_compat5.toString)(value), /[^0-9.]/g, "")) || 0),
-  import_zod40.z.unknown().transform(() => 0)
-]);
-
-// src/schema/widgets/post-purchase-offer/postPurchaseSettings.ts
-var PostPurchaseSettings = import_zod41.z.object({
-  advance: import_zod41.z.object({ removePartialOrder: import_zod41.z.boolean().default(true) }).optional().default(() => ({ removePartialOrder: true })),
-  blocks: import_zod41.z.union([import_zod41.z.array(PostPurchaseBlock), import_zod41.z.unknown().transform(() => [])]).default(() => [
-    PostPurchaseBlock.parse({ settings: {}, styles: {}, type: BlockType.timer }),
-    PostPurchaseBlock.parse({ settings: {}, styles: {}, type: BlockType.callout_banner }),
-    PostPurchaseBlock.parse({ type: BlockType.product_information })
-  ]),
-  columnLayout: import_zod41.z.boolean().optional(),
-  discount: import_zod41.z.object({
-    amount: strictNumber.default(30),
-    shouldShowSavingText: import_zod41.z.boolean().optional().default(true),
-    type: import_zod41.z.enum(["none", "fixed_amount", "percentage"]).default("none")
-  }),
-  discountedFrom: import_zod41.z.enum(["price", "compare_at_price"]).optional().default("price"),
-  endpoint: import_zod41.z.string().optional(),
-  integrations: import_zod41.z.object({
-    judgeme: import_zod41.z.boolean().default(false),
-    junip: import_zod41.z.boolean().optional().default(false),
-    klaviyo: import_zod41.z.boolean().default(false),
-    loox: import_zod41.z.boolean().default(false),
-    okendo: import_zod41.z.boolean().default(false),
-    opinew: import_zod41.z.boolean().optional().default(false),
-    reviewsio: import_zod41.z.boolean().optional().default(false),
-    stamped: import_zod41.z.boolean().default(false),
-    yotpo: import_zod41.z.boolean().default(false)
-  }),
-  key: import_zod41.z.string().optional(),
-  language: import_zod41.z.object({
-    description: import_zod41.z.union([import_zod41.z.string(), import_zod41.z.unknown().transform(() => "")]).default(""),
-    descriptionEnabled: import_zod41.z.boolean().optional().default(false),
-    descriptionRte: import_zod41.z.object({
-      content: import_zod41.z.array(import_zod41.z.unknown()),
-      type: import_zod41.z.string()
-    }).optional(),
-    descriptionSpacing: import_zod41.z.enum(["none", "xtight", "tight", "default", "loose", "xloose"]).optional(),
-    displayCtaPrice: import_zod41.z.boolean().default(true),
-    global: import_zod41.z.object({
-      declineAll: import_zod41.z.string().optional().default("Decline All"),
-      declineThisOffer: import_zod41.z.string().default("Decline this offer"),
-      free: import_zod41.z.string().optional().default("Free"),
-      notAvailable: import_zod41.z.string().optional().default("Not available"),
-      payNow: import_zod41.z.string().default("Pay Now"),
-      payNowUpgradeToSubscription: import_zod41.z.string().optional().default("Upgrade to Subscription"),
-      quantity: import_zod41.z.string().default("Quantity"),
-      /** This isn't configurable in the admin-nextjs editor */
-      recurringShipping: import_zod41.z.string().optional().default("Recurring shipping"),
-      recurringSubtotal: import_zod41.z.string().default("Recurring subtotal"),
-      reviewsPlural: import_zod41.z.string().optional().default("Reviews"),
-      reviewsSingular: import_zod41.z.string().optional().default("Review"),
-      save: import_zod41.z.union([import_zod41.z.string(), import_zod41.z.unknown().transform(() => "Save")]).optional().default("Save"),
-      shipping: import_zod41.z.string().default("Shipping"),
-      subscriptionOption: import_zod41.z.string().optional().default("Subscribe and Save"),
-      subtotal: import_zod41.z.string().default("Subtotal"),
-      taxes: import_zod41.z.string().default("Taxes"),
-      total: import_zod41.z.string().default("Total")
-    }).optional().default(() => ({
-      declineAll: "Decline All",
-      declineThisOffer: "Decline this offer",
-      free: "Free",
-      notAvailable: "Not available",
-      payNow: "Pay Now",
-      payNowUpgradeToSubscription: "Upgrade to Subscription",
-      quantity: "Quantity",
-      /** This isn't configurable in the admin-nextjs editor */
-      recurringShipping: "Recurring shipping",
-      recurringSubtotal: "Recurring subtotal",
-      reviewsPlural: "Reviews",
-      reviewsSingular: "Review",
-      save: "Save",
-      shipping: "Shipping",
-      subscriptionOption: "Subscribe and Save",
-      subtotal: "Subtotal",
-      taxes: "Taxes",
-      total: "Total"
-    })),
-    globalTranslation: import_zod41.z.string().optional().default("english")
-  }),
-  metafields: import_zod41.z.boolean().default(false),
-  /** This isn't configurable in the admin-nextjs editor */
-  offer: import_zod41.z.object({
-    count: import_zod41.z.number().default(1)
-  }),
-  offersLayout: import_zod41.z.object({
-    itemsPerPage: import_zod41.z.number().optional(),
-    type: import_zod41.z.enum(["list", "grid", "carousel"]).default("list")
-  }).optional().default({
-    type: "list"
-  }),
-  /** This isn't configurable in the admin-nextjs editor */
-  previewMode: import_zod41.z.boolean().default(false),
-  productLimit: import_zod41.z.number().optional().default(1),
-  productOptions: import_zod41.z.object({
-    /** This isn't configurable in the admin-nextjs editor */
-    hideOutOfStockVariants: import_zod41.z.boolean().optional().default(false),
-    matchVariant: import_zod41.z.boolean().optional().default(true),
-    showDeclineAll: import_zod41.z.enum(["above", "below", "both", "none"]).optional(),
-    showShipping: import_zod41.z.boolean().optional().default(true),
-    showSubtotal: import_zod41.z.boolean().optional().default(true),
-    showTaxes: import_zod41.z.boolean().optional().default(true),
-    showTotal: import_zod41.z.boolean().optional().default(true),
-    showVariantSelectors: import_zod41.z.boolean().optional().default(true),
-    variantSelectorDisplayMode: import_zod41.z.enum(["separate", "single"]).optional().default("separate")
-  }),
-  productType: import_zod41.z.union([import_zod41.z.enum(["one-time", "subscription", "both"]), import_zod41.z.literal("").transform(() => "one-time")]).default("one-time"),
-  productTypeSelector: import_zod41.z.enum(["dropdown", "radio"]).optional().default("radio"),
-  quantityInputs: import_zod41.z.object({
-    defaultQuantity: import_zod41.z.union([import_zod41.z.number(), import_zod41.z.null().transform(() => 1)]).default(1),
-    enabled: import_zod41.z.boolean().default(true),
-    maxValue: import_zod41.z.union([import_zod41.z.number(), import_zod41.z.null().transform(() => 15)]).default(15),
-    minValue: import_zod41.z.union([import_zod41.z.number().min(0), import_zod41.z.unknown().transform(() => 0)]).default(1)
-  }),
-  shipping: import_zod41.z.object({
-    amount: strictNumber.default(10),
-    /** This isn't configurable in the admin-nextjs editor */
-    enabled: import_zod41.z.boolean().default(true),
-    title: import_zod41.z.string().optional().default("Shipping Fees"),
-    type: import_zod41.z.enum(["free", "fixed_amount"]).default("free")
-  }),
-  styles: import_zod41.z.object({
-    starColor: import_zod41.z.string().optional().default("#fadb14"),
-    starSize: import_zod41.z.union([import_zod41.z.enum(["small", "medium", "large"]), import_zod41.z.unknown().transform(() => "large")]).optional().default("large"),
-    starStrokeColor: import_zod41.z.string().optional().default("#fadb14"),
-    strokeWidth: import_zod41.z.string().optional().default("1")
+  productId: PostPurchaseProductId,
+  sellingPlanAllocations: import_zod43.z.unknown().optional()
+});
+var Product2 = ProductBase.extend({
+  images: import_zod43.z.array(
+    import_zod43.z.object({ alt: import_zod43.z.string().optional().catch(void 0), id: import_zod43.z.number().int().positive(), src: import_zod43.z.string() })
+  ).nullish(),
+  metadata: import_zod43.z.object({
+    productQuantity: import_zod43.z.union([
+      import_zod43.z.number().int().positive(),
+      import_zod43.z.string().regex(/^[1-9]\d*$/).transform(Number)
+    ]).optional()
   }).optional(),
-  subImages: import_zod41.z.number().nullish().default(8),
-  subscription: import_zod41.z.object({
-    discount: import_zod41.z.object({
-      amount: strictNumber.default(30),
-      shouldShowSavingText: import_zod41.z.boolean().optional().default(true),
-      type: import_zod41.z.enum(["none", "fixed_amount", "percentage"]).default("none")
-    }),
-    shipping: import_zod41.z.object({
-      amount: strictNumber.default(1),
-      /** This isn't configurable in the admin-nextjs editor */
-      enabled: import_zod41.z.boolean().default(true),
-      /** This isn't configurable in the admin-nextjs editor */
-      recurringAmount: strictNumber.default(2),
-      shippingTitle: import_zod41.z.string().default("Shipping Fees"),
-      type: import_zod41.z.enum(["free", "fixed_amount"]).default("free")
+  metafields: import_zod43.z.unknown().optional(),
+  options: import_zod43.z.unknown().optional(),
+  productGroupVariants: import_zod43.z.array(import_zod43.z.unknown()).default([]),
+  selectedVariant: import_zod43.z.unknown().optional(),
+  sellingPlanGroups: import_zod43.z.array(
+    OfferProduct.shape.sellingPlanGroups.unwrap().element.extend({
+      discountAmount: import_zod43.z.unknown().optional(),
+      discountType: import_zod43.z.unknown().optional(),
+      id: import_zod43.z.unknown().optional(),
+      requiresSellingPlan: import_zod43.z.boolean().default(false),
+      sellingPlans: import_zod43.z.unknown().optional()
     })
-  }).optional().default({
-    discount: {
-      amount: 30,
-      shouldShowSavingText: true,
-      type: "none"
-    },
-    shipping: {
-      amount: 1,
-      /** This isn't configurable in the admin-nextjs editor */
-      enabled: true,
-      /** This isn't configurable in the admin-nextjs editor */
-      recurringAmount: 2,
-      shippingTitle: "Shipping Fees",
-      type: "free"
-    }
-  }),
-  subscriptionIsDefault: import_zod41.z.boolean().optional(),
-  /** This isn't configurable in the admin-nextjs editor */
-  template: import_zod41.z.string().optional().default(""),
-  type: import_zod41.z.literal("shopify_post_purchase_extension").default("shopify_post_purchase_extension"),
-  upgradeToSubscription: import_zod41.z.object({
-    acceptButtonText: import_zod41.z.string().optional().default("Upgrade"),
-    allow: import_zod41.z.boolean().optional().default(false),
-    emailRefundNotice: import_zod41.z.boolean().optional().default(false),
-    errorBannerText: import_zod41.z.string().optional().default("This subscription cannot be added - limit one per order")
-  }).optional().default(() => ({
-    acceptButtonText: "Upgrade",
-    allow: false,
-    emailRefundNotice: false,
-    errorBannerText: "This subscription cannot be added - limit one per order"
-  }))
+  ).default([]),
+  variants: import_zod43.z.array(SourceVariant)
+});
+var PostPurchaseProductSource = import_zod43.z.object({
+  data: import_zod43.z.array(Product2),
+  metadata: import_zod43.z.object({ widget: import_zod43.z.record(import_zod43.z.string(), import_zod43.z.unknown()).default({}) }).default({ widget: {} })
 });
 
 // src/schema/postPurchaseProductSettings.ts
-var amount = import_zod42.z.union([import_zod42.z.number().nonnegative(), PostPurchaseAmount.transform(Number)]);
+var amount = import_zod44.z.union([import_zod44.z.number().nonnegative(), PostPurchaseAmount.transform(Number)]);
 var PostPurchaseProductSettings = PostPurchaseSettings.pick({
   discountedFrom: true,
   language: true,
@@ -5805,14 +6018,14 @@ var PostPurchaseProductSettings = PostPurchaseSettings.pick({
   subscriptionIsDefault: true,
   upgradeToSubscription: true
 }).extend({
-  advance: import_zod42.z.unknown().default({}),
-  blocks: import_zod42.z.array(import_zod42.z.unknown()).optional(),
+  advance: import_zod44.z.unknown().default({}),
+  blocks: import_zod44.z.array(import_zod44.z.unknown()).optional(),
   discount: PostPurchaseSettings.shape.discount.extend({ amount: amount.default(30) }),
-  integrations: import_zod42.z.unknown().default({}),
+  integrations: import_zod44.z.unknown().default({}),
   shipping: PostPurchaseSettings.shape.shipping.extend({ amount: amount.default(10) }),
-  styles: import_zod42.z.unknown().default({}),
+  styles: import_zod44.z.unknown().default({}),
   subImages: PostPurchaseSettings.shape.subImages.catch(null),
-  subscription: import_zod42.z.unknown().default(PostPurchaseSettings.shape.subscription.parse(void 0))
+  subscription: import_zod44.z.unknown().default(PostPurchaseSettings.shape.subscription.parse(void 0))
 });
 
 // src/server/normalizePostPurchaseProduct.ts
@@ -5820,59 +6033,83 @@ var normalizePostPurchaseProduct = (settings, response) => {
   const original = PostPurchaseProductSettings.parse(deepCamelCase(settings));
   const { data, metadata } = PostPurchaseProductSource.parse(deepCamelCase(response));
   const overrides = Object.fromEntries(Object.entries(metadata.widget).filter(([key]) => key in original));
-  const discount = import_zod43.z.object({ type: import_zod43.z.string() }).safeParse(overrides.discount);
+  const discount = import_zod45.z.object({ type: import_zod45.z.string() }).safeParse(overrides.discount);
   if (discount.success && discount.data.type === "fixed") {
-    overrides.discount = { ...import_zod43.z.record(import_zod43.z.string(), import_zod43.z.unknown()).parse(overrides.discount), type: "fixed_amount" };
+    overrides.discount = { ...import_zod45.z.record(import_zod45.z.string(), import_zod45.z.unknown()).parse(overrides.discount), type: "fixed_amount" };
   }
-  const effective = PostPurchaseProductSettings.parse((0, import_compat6.merge)({}, original, overrides));
+  const effective = PostPurchaseProductSettings.parse((0, import_compat7.merge)({}, original, overrides));
   return { data, effective, metadata, original };
 };
 
+// src/pricing/amountToCents.ts
+var round = (value, precision = 0) => {
+  const factor = 10 ** precision;
+  return Math.round(value * factor) / factor;
+};
+var amountToCents = (amount2, decimals = 2) => {
+  const value = Number(amount2);
+  return Number.isFinite(value) ? round(round(value, decimals) * 10 ** decimals) : 0;
+};
+
+// src/pricing/postPurchaseReduction.ts
+var reducePostPurchaseMinor = (priceMinor, { amount: amount2, type }, decimals) => {
+  if (type === "price") return amountToCents(amount2, decimals);
+  const reduction = type === "percentage" ? Math.round(priceMinor * (amount2 / 100)) : type === "fixed_amount" ? amountToCents(amount2, decimals) : 0;
+  return Math.max(0, priceMinor - reduction);
+};
+var postPurchasePlanDiscountPercentage = (price, adjustment) => {
+  const regularMinor = amountToCents(price);
+  const planMinor = adjustment ? reducePostPurchaseMinor(regularMinor, adjustment, 2) : regularMinor;
+  return regularMinor > 0 && planMinor < regularMinor ? Math.round((1 - planMinor / regularMinor) * 100) : 0;
+};
+
 // src/schema/postPurchasePlanCatalog.ts
-var import_zod46 = require("zod");
+var import_zod48 = require("zod");
 
 // src/schema/postPurchasePlanAdjustment.ts
-var import_zod45 = require("zod");
+var import_zod47 = require("zod");
 
 // src/schema/postPurchaseDiscount.ts
-var import_zod44 = require("zod");
-var Discount = import_zod44.z.object({
-  amount: import_zod44.z.number().nonnegative(),
-  title: import_zod44.z.string(),
-  type: import_zod44.z.enum(["none", "fixed_amount", "percentage"])
+var import_zod46 = require("zod");
+var Discount = import_zod46.z.object({
+  amount: import_zod46.z.number().nonnegative(),
+  title: import_zod46.z.string(),
+  type: import_zod46.z.enum(["none", "fixed_amount", "percentage"])
 });
 var validPostPurchaseDiscount = (discount) => discount.type !== "percentage" || discount.amount <= 100;
 var PostPurchaseDiscount = Discount.refine(validPostPurchaseDiscount);
 
 // src/schema/postPurchasePlanAdjustment.ts
-var PostPurchasePlanAdjustment = import_zod45.z.object({
+var PostPurchasePlanAdjustment = import_zod47.z.object({
   amount: PostPurchaseDiscount.shape.amount,
-  type: import_zod45.z.enum(["percentage", "fixed_amount", "price"])
+  type: import_zod47.z.enum(["percentage", "fixed_amount", "price"])
 }).refine(({ amount: amount2, type }) => type === "price" || validPostPurchaseDiscount({ amount: amount2, type }));
 
 // src/schema/postPurchasePlanCatalog.ts
-var PostPurchasePlanOption = import_zod46.z.object({
+var PostPurchasePlanOption = import_zod48.z.object({
   adjustment: PostPurchasePlanAdjustment.optional(),
-  id: import_zod46.z.number().int().positive(),
-  intervalFrequency: import_zod46.z.string().regex(/^[1-9]\d*$/).optional(),
-  intervalLabel: import_zod46.z.string().min(1),
-  name: import_zod46.z.string().min(1)
+  /** cab-checkout's `discountPercentage`: the plan's own whole-percent saving on the regular price (`{{subscriptionDiscount}}`). */
+  discountPercentage: import_zod48.z.number().int().min(0).max(100).optional(),
+  id: import_zod48.z.number().int().positive(),
+  intervalFrequency: import_zod48.z.string().regex(/^[1-9]\d*$/).optional(),
+  intervalLabel: import_zod48.z.string().min(1),
+  name: import_zod48.z.string().min(1)
 });
-var PostPurchasePlanCatalog = import_zod46.z.object({
-  plans: import_zod46.z.array(PostPurchasePlanOption),
-  productId: import_zod46.z.number().int().positive(),
-  requiresSellingPlan: import_zod46.z.boolean(),
-  variantId: import_zod46.z.number().int().positive()
+var PostPurchasePlanCatalog = import_zod48.z.object({
+  plans: import_zod48.z.array(PostPurchasePlanOption),
+  productId: import_zod48.z.number().int().positive(),
+  requiresSellingPlan: import_zod48.z.boolean(),
+  variantId: import_zod48.z.number().int().positive()
 });
 
 // src/server/postPurchaseLegacyPlans.ts
-var import_zod48 = require("zod");
+var import_zod50 = require("zod");
 
 // src/server/postPurchasePlanAdjustment.ts
-var import_zod47 = require("zod");
-var SourceAdjustment = import_zod47.z.object({
+var import_zod49 = require("zod");
+var SourceAdjustment = import_zod49.z.object({
   amount: PostPurchaseProductSettings.shape.discount.shape.amount.unwrap(),
-  type: import_zod47.z.enum(["percentage", "fixed_amount", "amount", "price", "none", "fixed"])
+  type: import_zod49.z.enum(["percentage", "fixed_amount", "amount", "price", "none", "fixed"])
 });
 var readPostPurchasePlanAdjustment = (raw) => {
   const source2 = SourceAdjustment.parse(raw);
@@ -5891,13 +6128,13 @@ var readPostPurchasePlanAdjustment = (raw) => {
 var Plan = PostPurchasePlanOption.pick({ id: true, name: true }).extend({
   orderIntervalFrequency: PostPurchasePlanOption.shape.intervalFrequency.unwrap(),
   orderIntervalUnitType: PostPurchasePlanOption.shape.intervalLabel,
-  shopifyVariantId: import_zod48.z.string().regex(/^[1-9]\d*$/).nullish()
+  shopifyVariantId: import_zod50.z.string().regex(/^[1-9]\d*$/).nullish()
 });
-var Group = import_zod48.z.object({
-  discountAmount: import_zod48.z.unknown(),
-  discountType: import_zod48.z.unknown(),
-  id: import_zod48.z.number().int().positive(),
-  sellingPlans: import_zod48.z.array(import_zod48.z.object({ shopifyVariantId: Plan.shape.shopifyVariantId }).passthrough())
+var Group = import_zod50.z.object({
+  discountAmount: import_zod50.z.unknown(),
+  discountType: import_zod50.z.unknown(),
+  id: import_zod50.z.number().int().positive(),
+  sellingPlans: import_zod50.z.array(import_zod50.z.object({ shopifyVariantId: Plan.shape.shopifyVariantId }).passthrough())
 });
 var readPostPurchaseLegacyPlans = (raw, variantId) => {
   const group = Group.pick({ id: true, sellingPlans: true }).parse(raw);
@@ -5918,21 +6155,21 @@ var readPostPurchaseLegacyPlans = (raw, variantId) => {
 };
 
 // src/server/postPurchaseModernPlans.ts
-var import_zod49 = require("zod");
-var Groups = import_zod49.z.array(
-  import_zod49.z.object({
-    id: import_zod49.z.string().min(1),
-    sellingPlans: import_zod49.z.unknown()
+var import_zod51 = require("zod");
+var Groups = import_zod51.z.array(
+  import_zod51.z.object({
+    id: import_zod51.z.string().min(1),
+    sellingPlans: import_zod51.z.unknown()
   })
 );
-var Allocations = import_zod49.z.array(import_zod49.z.object({ sellingPlanGroupId: import_zod49.z.string().min(1) })).default([]);
-var Plans = import_zod49.z.array(
+var Allocations = import_zod51.z.array(import_zod51.z.object({ sellingPlanGroupId: import_zod51.z.string().min(1) })).default([]);
+var Plans = import_zod51.z.array(
   PostPurchasePlanOption.pick({ id: true, name: true }).extend({
-    options: import_zod49.z.array(import_zod49.z.object({ value: import_zod49.z.string().min(1) })).min(1),
-    priceAdjustments: import_zod49.z.array(import_zod49.z.unknown())
+    options: import_zod51.z.array(import_zod51.z.object({ value: import_zod51.z.string().min(1) })).min(1),
+    priceAdjustments: import_zod51.z.array(import_zod51.z.unknown())
   })
 );
-var FirstAdjustment = import_zod49.z.object({
+var FirstAdjustment = import_zod51.z.object({
   value: PostPurchaseProductSettings.shape.discount.shape.amount.unwrap(),
   valueType: PostPurchasePlanAdjustment.shape.type
 });
@@ -5972,7 +6209,10 @@ var projectPostPurchasePlanCatalog = (normalized, report) => {
       unique.set(plan.id, plan);
     }
     return PostPurchasePlanCatalog.parse({
-      plans: [...unique.values()],
+      plans: [...unique.values()].map((plan) => ({
+        ...plan,
+        discountPercentage: postPurchasePlanDiscountPercentage(variant2.price, plan.adjustment)
+      })),
       productId: product.id,
       requiresSellingPlan: required[0] ?? false,
       variantId: variant2.id
@@ -5984,66 +6224,66 @@ var projectPostPurchasePlanCatalog = (normalized, report) => {
 };
 
 // src/schema/postPurchaseSubscriptionProduct.ts
-var import_zod55 = require("zod");
+var import_zod57 = require("zod");
 
 // src/schema/postPurchaseProduct.ts
-var import_zod54 = require("zod");
+var import_zod56 = require("zod");
 
 // src/schema/postPurchaseProductDisplay.ts
-var import_zod52 = require("zod");
+var import_zod54 = require("zod");
 
 // src/schema/postPurchaseProductGallery.ts
-var import_zod50 = require("zod");
-var PostPurchaseProductGallery = import_zod50.z.object({
-  images: import_zod50.z.array(
-    import_zod50.z.object({
-      description: import_zod50.z.string(),
-      id: import_zod50.z.number().int().positive(),
-      source: import_zod50.z.string(),
-      thumbnail: import_zod50.z.string()
+var import_zod52 = require("zod");
+var PostPurchaseProductGallery = import_zod52.z.object({
+  images: import_zod52.z.array(
+    import_zod52.z.object({
+      description: import_zod52.z.string(),
+      id: import_zod52.z.number().int().positive(),
+      source: import_zod52.z.string(),
+      thumbnail: import_zod52.z.string()
     })
   ),
-  selectedImageId: import_zod50.z.number().int().positive().optional()
+  selectedImageId: import_zod52.z.number().int().positive().optional()
 });
 
 // src/schema/postPurchaseProductReviews.ts
-var import_zod51 = require("zod");
-var decimal = import_zod51.z.union([
-  import_zod51.z.number(),
-  import_zod51.z.string().regex(/^\d+(?:\.\d+)?$/).transform(Number)
+var import_zod53 = require("zod");
+var decimal = import_zod53.z.union([
+  import_zod53.z.number(),
+  import_zod53.z.string().regex(/^\d+(?:\.\d+)?$/).transform(Number)
 ]);
-var PostPurchaseCommonReviewRating = import_zod51.z.object({ value: decimal.pipe(import_zod51.z.number().min(0).max(5)) });
+var PostPurchaseCommonReviewRating = import_zod53.z.object({ value: decimal.pipe(import_zod53.z.number().min(0).max(5)) });
 var PostPurchaseKlaviyoReviewRating = PostPurchaseCommonReviewRating.extend({
   // Legacy validates key presence, then displays the raw value on five stars without rescaling.
-  scale_max: import_zod51.z.unknown().nonoptional(),
-  scale_min: import_zod51.z.unknown().nonoptional()
+  scale_max: import_zod53.z.unknown().nonoptional(),
+  scale_min: import_zod53.z.unknown().nonoptional()
 });
-var PostPurchaseReviewCount = import_zod51.z.string().regex(/^\d+(?:\.\d+)?$/).transform(Number).pipe(import_zod51.z.number().int().nonnegative());
+var PostPurchaseReviewCount = import_zod53.z.string().regex(/^\d+(?:\.\d+)?$/).transform(Number).pipe(import_zod53.z.number().int().nonnegative());
 var PostPurchaseReviewStyles = PostPurchaseSettings.shape.styles.unwrap().extend({
-  strokeWidth: decimal.pipe(import_zod51.z.number().nonnegative()).default(1)
+  strokeWidth: decimal.pipe(import_zod53.z.number().nonnegative()).default(1)
 }).prefault({});
-var PostPurchaseProductReviews = import_zod51.z.object({
-  color: import_zod51.z.string(),
-  rating: import_zod51.z.number().positive().max(5),
-  reviewCount: import_zod51.z.number().int().nonnegative(),
-  reviewsPlural: import_zod51.z.string(),
-  reviewsSingular: import_zod51.z.string(),
-  size: import_zod51.z.enum(["small", "medium", "large"]),
-  strokeColor: import_zod51.z.string(),
-  strokeWidth: import_zod51.z.number().nonnegative()
+var PostPurchaseProductReviews = import_zod53.z.object({
+  color: import_zod53.z.string(),
+  rating: import_zod53.z.number().positive().max(5),
+  reviewCount: import_zod53.z.number().int().nonnegative(),
+  reviewsPlural: import_zod53.z.string(),
+  reviewsSingular: import_zod53.z.string(),
+  size: import_zod53.z.enum(["small", "medium", "large"]),
+  strokeColor: import_zod53.z.string(),
+  strokeWidth: import_zod53.z.number().nonnegative()
 });
 
 // src/schema/postPurchaseProductDisplay.ts
 var language = PostPurchaseSettings.shape.language;
-var PostPurchasePrimaryImageSource = import_zod52.z.string().default(
+var PostPurchasePrimaryImageSource = import_zod54.z.string().default(
   "https://cdn.shopify.com/shopifycloud/shopify/assets/no-image-2048-5e88c1b20e087fb7bbe9a3771824e743c244f437e4f8ba93bbf7b11b53f7824c.gif"
 );
-var PostPurchaseProductDisplay = import_zod52.z.object({
+var PostPurchaseProductDisplay = import_zod54.z.object({
   descriptionDocument: TiptapDocument.optional(),
   discountedFrom: PostPurchaseSettings.shape.discountedFrom,
   gallery: PostPurchaseProductGallery.optional(),
   language: language.pick({ description: true, descriptionEnabled: true }),
-  primaryImage: import_zod52.z.object({ description: import_zod52.z.string(), source: import_zod52.z.string() }),
+  primaryImage: import_zod54.z.object({ description: import_zod54.z.string(), source: import_zod54.z.string() }),
   productOptions: PostPurchaseSettings.shape.productOptions.pick({
     showDeclineAll: true,
     showShipping: true,
@@ -6058,14 +6298,14 @@ var PostPurchaseProductDisplay = import_zod52.z.object({
 });
 
 // src/schema/postPurchaseSubscription.ts
-var import_zod53 = require("zod");
-var PostPurchaseSubscriptionTerms = import_zod53.z.object({
+var import_zod55 = require("zod");
+var PostPurchaseSubscriptionTerms = import_zod55.z.object({
   adjustment: PostPurchasePlanAdjustment.optional(),
-  initialShippingPrice: import_zod53.z.number().nonnegative(),
-  intervalLabel: import_zod53.z.string().min(1),
-  name: import_zod53.z.string().min(1),
-  recurringShippingPrice: import_zod53.z.number().nonnegative(),
-  shippingOption: import_zod53.z.object({ presentmentTitle: import_zod53.z.string(), title: import_zod53.z.string() })
+  initialShippingPrice: import_zod55.z.number().nonnegative(),
+  intervalLabel: import_zod55.z.string().min(1),
+  name: import_zod55.z.string().min(1),
+  recurringShippingPrice: import_zod55.z.number().nonnegative(),
+  shippingOption: import_zod55.z.object({ presentmentTitle: import_zod55.z.string(), title: import_zod55.z.string() })
 });
 
 // src/schema/postPurchaseProduct.ts
@@ -6075,51 +6315,52 @@ var PostPurchaseVariant = OfferProduct.shape.variants.element.pick({ id: true, t
   id: PostPurchaseVariantId,
   price: PostPurchaseAmount
 });
-var PreparedPostPurchaseProduct = import_zod54.z.object({
+var PreparedPostPurchaseProduct = import_zod56.z.object({
   display: PostPurchaseProductDisplay,
-  labels: import_zod54.z.object({
+  labels: import_zod56.z.object({
     declineAll: global.declineAll,
-    free: import_zod54.z.string(),
-    payNow: import_zod54.z.string(),
-    quantity: import_zod54.z.string(),
+    free: import_zod56.z.string(),
+    notAvailable: global.notAvailable,
+    payNow: import_zod56.z.string(),
+    quantity: import_zod56.z.string(),
     recurringShipping: global.recurringShipping,
     recurringSubtotal: global.recurringSubtotal,
-    save: import_zod54.z.string(),
-    shipping: import_zod54.z.string(),
-    subtotal: import_zod54.z.string(),
-    taxes: import_zod54.z.string(),
-    total: import_zod54.z.string()
+    save: import_zod56.z.string(),
+    shipping: import_zod56.z.string(),
+    subtotal: import_zod56.z.string(),
+    taxes: import_zod56.z.string(),
+    total: import_zod56.z.string()
   }),
   product: OfferProduct.pick({ description: true, id: true, image: true, title: true }).extend({
     description: OfferProduct.shape.description.nullable(),
     id: PostPurchaseProductId,
     variant: PostPurchaseVariant
   }),
-  selection: import_zod54.z.object({
+  selection: import_zod56.z.object({
     productId: PostPurchaseProductId,
-    quantity: import_zod54.z.number().int().positive(),
-    sellingPlanId: import_zod54.z.number().int().positive().optional(),
+    quantity: import_zod56.z.number().int().positive(),
+    sellingPlanId: import_zod56.z.number().int().positive().optional(),
     variantId: PostPurchaseVariantId
   }),
-  status: import_zod54.z.literal("prepared"),
-  terms: import_zod54.z.object({
+  status: import_zod56.z.literal("prepared"),
+  terms: import_zod56.z.object({
     discount: PostPurchaseDiscount,
-    shipping: import_zod54.z.object({
-      amount: import_zod54.z.number().nonnegative(),
-      title: import_zod54.z.string(),
-      type: import_zod54.z.enum(["free", "fixed_amount"])
+    shipping: import_zod56.z.object({
+      amount: import_zod56.z.number().nonnegative(),
+      title: import_zod56.z.string(),
+      type: import_zod56.z.enum(["free", "fixed_amount"])
     }),
     subscription: PostPurchaseSubscriptionTerms.optional()
   })
 });
-var PostPurchasePreparation = import_zod54.z.discriminatedUnion("status", [
+var PostPurchasePreparation = import_zod56.z.discriminatedUnion("status", [
   PreparedPostPurchaseProduct,
-  import_zod54.z.object({ reason: import_zod54.z.string(), status: import_zod54.z.literal("unsupported") })
+  import_zod56.z.object({ reason: import_zod56.z.string(), status: import_zod56.z.literal("unsupported") })
 ]);
 
 // src/schema/postPurchaseSubscriptionProduct.ts
 var PreparedPostPurchaseSubscription = PreparedPostPurchaseProduct.extend({
-  selection: PreparedPostPurchaseProduct.shape.selection.extend({ sellingPlanId: import_zod55.z.number().int().positive() }),
+  selection: PreparedPostPurchaseProduct.shape.selection.extend({ sellingPlanId: import_zod57.z.number().int().positive() }),
   terms: PreparedPostPurchaseProduct.shape.terms.extend({
     subscription: PostPurchaseSubscriptionTerms
   }).refine(
@@ -6142,12 +6383,12 @@ var PostPurchaseSubscriptionSettings = subscription.extend({
 var postPurchaseVariantAvailable = (variant2) => !(variant2.inventoryManagement && variant2.inventoryPolicy === "deny" && variant2.inventoryQuantity <= 0);
 
 // src/server/postPurchaseSubscriptionEligibility.ts
-var subscriptionUnavailable = (normalized, plan, allowCollection, quantity2) => {
+var subscriptionUnavailable = (normalized, plan, allowCollection, quantity3) => {
   const { data, effective, original } = normalized;
   const unavailable = "An eligible subscription plan with supported shipping and discount is required";
   if (data.length !== 1 || data[0].variants.length !== 1) return unavailable;
   if (effective.productType === "one-time" || [original, effective].some(
-    (config) => !allowCollection && config.productLimit !== 1 || config.upgradeToSubscription.allow || !quantity2 && config.quantityInputs.enabled && (config.quantityInputs.minValue !== config.quantityInputs.maxValue || config.quantityInputs.defaultQuantity !== config.quantityInputs.minValue)
+    (config) => !allowCollection && config.productLimit !== 1 || config.upgradeToSubscription.allow || !quantity3 && config.quantityInputs.enabled && (config.quantityInputs.minValue !== config.quantityInputs.maxValue || config.quantityInputs.defaultQuantity !== config.quantityInputs.minValue)
   ))
     return unavailable;
   const product = data[0];
@@ -6161,7 +6402,7 @@ var subscriptionUnavailable = (normalized, plan, allowCollection, quantity2) =>
 };
 
 // src/server/postPurchaseProductDisplay.ts
-var import_zod57 = require("zod");
+var import_zod59 = require("zod");
 
 // src/server/postPurchasePrimaryImage.ts
 var postPurchasePrimaryImage = (product) => {
@@ -6183,7 +6424,7 @@ var postPurchaseProductGallery = (product, limit) => ({
 });
 
 // src/transforms/postPurchase/convertDescriptionRte.ts
-var import_zod56 = require("zod");
+var import_zod58 = require("zod");
 var alignments = { center: "center", left: "start", right: "end" };
 var colors = ["critical", "subdued", "success", "warning"];
 var sizes2 = ["extraSmall", "small", "medium", "large", "extraLarge"];
@@ -6195,19 +6436,19 @@ var spacings2 = {
   xloose: "extraLoose",
   xtight: "extraTight"
 };
-var Block = import_zod56.z.object({
-  attrs: import_zod56.z.object({ alignment: import_zod56.z.enum(["left", "center", "right"]).optional().catch(void 0) }).catch({}),
-  content: import_zod56.z.array(import_zod56.z.unknown()).catch([]),
-  type: import_zod56.z.literal("ShopifyTextBlock")
-});
-var Run = import_zod56.z.object({ marks: import_zod56.z.array(import_zod56.z.unknown()).catch([]), text: import_zod56.z.string().min(1), type: import_zod56.z.literal("text") });
-var Inline = import_zod56.z.object({
-  attrs: import_zod56.z.object({
-    color: import_zod56.z.enum(colors).optional().catch(void 0),
-    emphasis: import_zod56.z.array(import_zod56.z.unknown()).catch([]),
-    size: import_zod56.z.enum(sizes2).optional().catch(void 0)
+var Block = import_zod58.z.object({
+  attrs: import_zod58.z.object({ alignment: import_zod58.z.enum(["left", "center", "right"]).optional().catch(void 0) }).catch({}),
+  content: import_zod58.z.array(import_zod58.z.unknown()).catch([]),
+  type: import_zod58.z.literal("ShopifyTextBlock")
+});
+var Run = import_zod58.z.object({ marks: import_zod58.z.array(import_zod58.z.unknown()).catch([]), text: import_zod58.z.string().min(1), type: import_zod58.z.literal("text") });
+var Inline = import_zod58.z.object({
+  attrs: import_zod58.z.object({
+    color: import_zod58.z.enum(colors).optional().catch(void 0),
+    emphasis: import_zod58.z.array(import_zod58.z.unknown()).catch([]),
+    size: import_zod58.z.enum(sizes2).optional().catch(void 0)
   }),
-  type: import_zod56.z.literal("ShopifyTextInline")
+  type: import_zod58.z.literal("ShopifyTextInline")
 });
 var marks = (raw) => {
   const found = raw.map((mark) => Inline.safeParse(mark)).find(({ success }) => success)?.data;
@@ -6240,7 +6481,7 @@ var convertDescriptionRte = (rte, spacing) => TiptapDocument.parse({
 });
 
 // src/server/postPurchaseProductDisplay.ts
-var ResponseLanguage = import_zod57.z.object({ description: PostPurchaseProductDisplay.shape.responseDescription }).default({ description: "" });
+var ResponseLanguage = import_zod59.z.object({ description: PostPurchaseProductDisplay.shape.responseDescription }).default({ description: "" });
 var projectPostPurchaseProductDisplay = (effective, metadata, product) => PostPurchaseProductDisplay.parse({
   descriptionDocument: effective.language.descriptionRte && convertDescriptionRte(effective.language.descriptionRte, effective.language.descriptionSpacing),
   discountedFrom: effective.discountedFrom,
@@ -6253,14 +6494,14 @@ var projectPostPurchaseProductDisplay = (effective, metadata, product) => PostPu
 });
 
 // src/server/postPurchaseReviewData.ts
-var import_zod61 = require("zod");
+var import_zod63 = require("zod");
 
 // src/server/postPurchaseJudgeMeReviews.ts
-var import_zod58 = require("zod");
+var import_zod60 = require("zod");
 var readJudgeMeReviews = (find) => {
   const field = find("judgeme", "badge");
   if (!field) return null;
-  const html = import_zod58.z.string().parse(field.value);
+  const html = import_zod60.z.string().parse(field.value);
   const rating = html.match(/data-average-rating=['"](\d+(?:\.\d+)?)['"]/);
   const count = html.match(/data-number-of-reviews=['"](\d+)['"]/);
   if (!rating || !count) throw new Error("Unreadable Judge.me attributes");
@@ -6271,26 +6512,26 @@ var readJudgeMeReviews = (find) => {
 };
 
 // src/server/postPurchaseOkendoReviews.ts
-var import_zod59 = require("zod");
-var Summary = import_zod59.z.object({
+var import_zod61 = require("zod");
+var Summary = import_zod61.z.object({
   reviewAverageValue: PostPurchaseCommonReviewRating.shape.value,
-  reviewCount: import_zod59.z.union([PostPurchaseProductReviews.shape.reviewCount, PostPurchaseReviewCount])
+  reviewCount: import_zod61.z.union([PostPurchaseProductReviews.shape.reviewCount, PostPurchaseReviewCount])
 });
 var readOkendoReviews = (find) => {
   const field = find("okendo", "summaryData");
   if (!field) return null;
-  const summary = Summary.parse(JSON.parse(import_zod59.z.string().parse(field.value)));
+  const summary = Summary.parse(JSON.parse(import_zod61.z.string().parse(field.value)));
   return { rating: summary.reviewAverageValue, reviewCount: summary.reviewCount };
 };
 
 // src/server/postPurchaseScalarReviews.ts
-var import_zod60 = require("zod");
+var import_zod62 = require("zod");
 var readScalarReviews = (find, namespace, ratingKey, countKey) => {
   const rating = find(namespace, ratingKey);
   const count = find(namespace, countKey);
   if (!rating || !count) return null;
   return {
-    rating: PostPurchaseCommonReviewRating.parse({ value: import_zod60.z.string().parse(rating.value) }).value,
+    rating: PostPurchaseCommonReviewRating.parse({ value: import_zod62.z.string().parse(rating.value) }).value,
     reviewCount: PostPurchaseReviewCount.parse(count.value)
   };
 };
@@ -6309,16 +6550,16 @@ var readPostPurchaseReviewData = (provider, find) => {
   const count = find("reviews", "rating_count");
   if (!rating || !count) return null;
   return {
-    rating: PostPurchaseKlaviyoReviewRating.parse(JSON.parse(import_zod61.z.string().parse(rating.value))).value,
+    rating: PostPurchaseKlaviyoReviewRating.parse(JSON.parse(import_zod63.z.string().parse(rating.value))).value,
     reviewCount: PostPurchaseReviewCount.parse(count.value)
   };
 };
 
 // src/server/postPurchaseReviewFields.ts
-var import_zod62 = require("zod");
-var Field = import_zod62.z.object({ key: import_zod62.z.string(), namespace: import_zod62.z.string(), value: import_zod62.z.unknown().optional() });
+var import_zod64 = require("zod");
+var Field = import_zod64.z.object({ key: import_zod64.z.string(), namespace: import_zod64.z.string(), value: import_zod64.z.unknown().optional() });
 var reviewFields = (raw) => {
-  const fields4 = import_zod62.z.array(import_zod62.z.unknown()).parse(raw).flatMap((field) => {
+  const fields4 = import_zod64.z.array(import_zod64.z.unknown()).parse(raw).flatMap((field) => {
     const parsed = Field.safeParse(field);
     return parsed.success ? [parsed.data] : [];
   });
@@ -6326,8 +6567,8 @@ var reviewFields = (raw) => {
 };
 
 // src/server/postPurchaseReviewProvider.ts
-var import_zod63 = require("zod");
-var IntegrationInput = import_zod63.z.record(import_zod63.z.string(), import_zod63.z.unknown()).prefault({});
+var import_zod65 = require("zod");
+var IntegrationInput = import_zod65.z.record(import_zod65.z.string(), import_zod65.z.unknown()).prefault({});
 var precedence = [
   "klaviyo",
   "judgeme",
@@ -6339,7 +6580,7 @@ var precedence = [
   "stamped",
   "yotpo"
 ];
-var ReviewsIoFlag = import_zod63.z.preprocess((value) => {
+var ReviewsIoFlag = import_zod65.z.preprocess((value) => {
   if (typeof value === "string") {
     const flag = value.toLowerCase();
     if (flag === "true" || flag === "yes") return true;
@@ -6399,12 +6640,12 @@ var projectPostPurchaseProduct = ({ data, effective, metadata, original }, repor
 };
 
 // src/server/prepareNormalizedSubscription.ts
-var prepareNormalizedSubscription = (normalized, report, plan, quantity2, allowCollection = false) => {
+var prepareNormalizedSubscription = (normalized, report, plan, quantity3, allowCollection = false) => {
   if (!plan) return { reason: "Subscription plan is unavailable", status: "unsupported" };
-  const reason = subscriptionUnavailable(normalized, plan, allowCollection, quantity2);
+  const reason = subscriptionUnavailable(normalized, plan, allowCollection, quantity3);
   if (reason) return { reason, status: "unsupported" };
   const { effective } = normalized;
-  const projected = projectPostPurchaseProduct(normalized, report, quantity2);
+  const projected = projectPostPurchaseProduct(normalized, report, quantity3);
   const { discount, shipping } = PostPurchaseSubscriptionSettings.parse(effective.subscription);
   const shippingPrice = shipping.type === "free" ? 0 : shipping.amount;
   return PreparedPostPurchaseSubscription.parse({
@@ -6442,11 +6683,11 @@ var preparePostPurchaseSubscription = (settings, response, report) => {
 };
 
 // src/server/postPurchaseProductEligibility.ts
-var oneTimeUnavailable = (normalized, allowCollection, quantity2) => {
+var oneTimeUnavailable = (normalized, allowCollection, quantity3) => {
   const { data, effective, original } = normalized;
   if (data.length !== 1 || data[0].variants.length !== 1) return "Only one fixed product and variant are supported";
   if (effective.productType === "subscription" || [original, effective].some(
-    (config) => !allowCollection && config.productLimit !== 1 || config.upgradeToSubscription.allow || !quantity2 && config.quantityInputs.enabled && (config.quantityInputs.minValue !== config.quantityInputs.maxValue || config.quantityInputs.defaultQuantity !== config.quantityInputs.minValue)
+    (config) => !allowCollection && config.productLimit !== 1 || config.upgradeToSubscription.allow || !quantity3 && config.quantityInputs.enabled && (config.quantityInputs.minValue !== config.quantityInputs.maxValue || config.quantityInputs.defaultQuantity !== config.quantityInputs.minValue)
   ))
     return "Only fixed one-time configuration is supported";
   const product = data[0];
@@ -6457,12 +6698,12 @@ var oneTimeUnavailable = (normalized, allowCollection, quantity2) => {
 };
 
 // src/server/preparePostPurchaseProduct.ts
-var prepareNormalizedProduct = (normalized, report, quantity2, allowCollection = false) => {
-  const reason = oneTimeUnavailable(normalized, allowCollection, quantity2);
+var prepareNormalizedProduct = (normalized, report, quantity3, allowCollection = false) => {
+  const reason = oneTimeUnavailable(normalized, allowCollection, quantity3);
   if (reason) return { reason, status: "unsupported" };
   const { effective } = normalized;
   return PreparedPostPurchaseProduct.parse({
-    ...projectPostPurchaseProduct(normalized, report, quantity2),
+    ...projectPostPurchaseProduct(normalized, report, quantity3),
     status: "prepared",
     terms: {
       discount: { ...effective.discount, title: effective.language.global.save },
@@ -6473,45 +6714,80 @@ var prepareNormalizedProduct = (normalized, report, quantity2, allowCollection =
 var preparePostPurchaseProduct = (settings, response, report) => prepareNormalizedProduct(normalizePostPurchaseProduct(settings, response), report);
 
 // src/schema/postPurchaseProductView.ts
-var import_zod67 = require("zod");
+var import_zod72 = require("zod");
 
 // src/schema/postPurchaseChoice.ts
-var import_zod64 = require("zod");
-var PostPurchaseChoice = import_zod64.z.discriminatedUnion("mode", [
-  import_zod64.z.object({ mode: import_zod64.z.literal("one-time") }).strict(),
-  import_zod64.z.object({ mode: import_zod64.z.literal("subscription"), sellingPlanId: PostPurchasePlanOption.shape.id }).strict()
+var import_zod66 = require("zod");
+var PostPurchaseChoice = import_zod66.z.discriminatedUnion("mode", [
+  import_zod66.z.object({ mode: import_zod66.z.literal("one-time") }).strict(),
+  import_zod66.z.object({ mode: import_zod66.z.literal("subscription"), sellingPlanId: PostPurchasePlanOption.shape.id }).strict()
 ]);
-var PostPurchaseOptions = import_zod64.z.object({
+var PostPurchaseOptions = import_zod66.z.object({
   defaultChoice: PostPurchaseChoice,
-  modes: import_zod64.z.array(import_zod64.z.enum(["one-time", "subscription"])).min(1).max(2),
+  modes: import_zod66.z.array(import_zod66.z.enum(["one-time", "subscription"])).min(1).max(2),
   selector: PostPurchaseSettings.shape.productTypeSelector
 });
 
+// src/schema/postPurchaseDisplayPrice.ts
+var import_zod68 = require("zod");
+
+// src/schema/postPurchaseSubscriptionDisplay.ts
+var import_zod67 = require("zod");
+var Minor = import_zod67.z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+var PostPurchaseSubscriptionDisplay = import_zod67.z.object({
+  comparisonMinor: Minor,
+  currencyCode: import_zod67.z.string().regex(/^[A-Z]{3}$/),
+  priceMinor: Minor,
+  savingMinor: Minor,
+  savingPercent: import_zod67.z.number().int().min(0).max(100)
+});
+
+// src/schema/postPurchaseDisplayPrice.ts
+var { currencyCode: CurrencyCode, priceMinor: Minor2, savingPercent: Percent } = PostPurchaseSubscriptionDisplay.shape;
+var PostPurchaseDisplayPrice = import_zod68.z.object({
+  currencyCode: CurrencyCode,
+  savingFormat: import_zod68.z.enum(["amount", "percent"]),
+  savingMinor: Minor2,
+  savingPercent: Percent,
+  subscriptionUnit: PostPurchaseSubscriptionDisplay.optional(),
+  variantCompareAtPriceMinor: Minor2.nullable(),
+  variantPriceMinor: Minor2
+}).refine(
+  ({ variantCompareAtPriceMinor: struck, variantPriceMinor: price }) => struck === null || struck > price,
+  "A compare-at price is struck only above the price"
+).refine(
+  ({ savingMinor, savingPercent, variantCompareAtPriceMinor: struck, variantPriceMinor: price }) => savingMinor === (struck ?? price) - price && (savingMinor > 0 || savingPercent === 0),
+  "The saving is the struck price minus the price"
+).refine(
+  ({ subscriptionUnit: unit, ...facts }) => !unit || unit.currencyCode === facts.currencyCode && unit.priceMinor === facts.variantPriceMinor && unit.savingMinor === facts.savingMinor && unit.savingPercent === facts.savingPercent && unit.savingMinor === Math.max(0, unit.comparisonMinor - unit.priceMinor),
+  "The subscription unit estimate restates the plan facts in the same currency"
+);
+
 // src/schema/postPurchaseGroupCatalog.ts
-var import_zod66 = require("zod");
+var import_zod70 = require("zod");
 
 // src/schema/postPurchaseVariantCatalog.ts
-var import_zod65 = require("zod");
-var PostPurchaseVariantSelector = import_zod65.z.object({ variantId: PostPurchaseVariantId }).strict();
+var import_zod69 = require("zod");
+var PostPurchaseVariantSelector = import_zod69.z.object({ variantId: PostPurchaseVariantId }).strict();
 var PostPurchaseVariantOption = OfferProduct.shape.options.element.extend({
-  id: import_zod65.z.number().int().positive(),
-  position: import_zod65.z.number().int().min(1).max(3)
+  id: import_zod69.z.number().int().positive(),
+  position: import_zod69.z.number().int().min(1).max(3)
 });
 var PostPurchaseVariantValues = OfferProduct.shape.variants.element.pick({
   option1: true,
   option2: true,
   option3: true
 });
-var PostPurchaseVariantCatalog = import_zod65.z.object({
+var PostPurchaseVariantCatalog = import_zod69.z.object({
   displayMode: PostPurchaseSettings.shape.productOptions.shape.variantSelectorDisplayMode,
-  options: import_zod65.z.array(PostPurchaseVariantOption),
+  options: import_zod69.z.array(PostPurchaseVariantOption),
   productId: PostPurchaseProductId,
   showSelectors: PostPurchaseSettings.shape.productOptions.shape.showVariantSelectors,
-  variants: import_zod65.z.array(
+  variants: import_zod69.z.array(
     PostPurchaseVariantValues.partial().extend({
-      available: import_zod65.z.boolean(),
+      available: import_zod69.z.boolean(),
       id: PostPurchaseVariantId,
-      imageId: import_zod65.z.number().int().nonnegative().nullish(),
+      imageId: import_zod69.z.number().int().nonnegative().nullish(),
       title: OfferProduct.shape.variants.element.shape.title
     })
   )
@@ -6525,23 +6801,89 @@ var PostPurchaseGroupDescription = source.pick({ description: true, id: true, im
   image: source.shape.image.default(null),
   options: PostPurchaseVariantCatalog.shape.options.default([])
 });
-var PostPurchaseGroupCatalog = import_zod66.z.object({
+var PostPurchaseGroupCatalog = import_zod70.z.object({
   memberProductId: productId,
-  options: import_zod66.z.array(import_zod66.z.object({ productId, title: import_zod66.z.string(), variantCatalog: PostPurchaseVariantCatalog }))
+  options: import_zod70.z.array(import_zod70.z.object({ productId, title: import_zod70.z.string(), variantCatalog: PostPurchaseVariantCatalog }))
 });
-var PostPurchaseGroupSelection = import_zod66.z.object({
+var PostPurchaseGroupSelection = import_zod70.z.object({
   memberProductId: productId,
   productId
 });
 
+// src/schema/postPurchaseProductCalculation.ts
+var import_zod71 = require("zod");
+var MoneyBag = import_zod71.z.object({
+  presentmentMoney: import_zod71.z.object({
+    amount: PostPurchaseAmount,
+    currencyCode: import_zod71.z.string().regex(/^[A-Z]{3}$/)
+  })
+});
+var PostPurchaseProductCalculation = import_zod71.z.object({
+  calculatedPurchase: import_zod71.z.object({
+    addedShippingLines: import_zod71.z.array(import_zod71.z.object({ priceSet: MoneyBag })),
+    addedTaxLines: import_zod71.z.array(import_zod71.z.object({ priceSet: MoneyBag })),
+    totalOutstandingSet: MoneyBag,
+    updatedLineItems: import_zod71.z.array(
+      import_zod71.z.object({
+        priceSet: import_zod71.z.unknown().optional(),
+        productId: import_zod71.z.number().int().positive(),
+        sellingPlanId: import_zod71.z.unknown().optional(),
+        variantId: import_zod71.z.number().int().positive()
+      })
+    )
+  }),
+  errors: import_zod71.z.array(import_zod71.z.unknown()).length(0),
+  status: import_zod71.z.literal("processed")
+});
+var Minor3 = import_zod71.z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+var PostPurchaseProductCosts = import_zod71.z.object({
+  currencyCode: MoneyBag.shape.presentmentMoney.shape.currencyCode,
+  recurringDisplay: import_zod71.z.object({ shippingMinor: Minor3, subtotalMinor: Minor3, totalMinor: Minor3 }).optional(),
+  shippingMinor: Minor3,
+  subtotalMinor: Minor3,
+  taxesMinor: Minor3,
+  totalMinor: Minor3
+});
+var ChangesetDiscount = import_zod71.z.object({
+  title: import_zod71.z.string(),
+  value: import_zod71.z.number().nonnegative(),
+  valueType: import_zod71.z.enum(["percentage", "fixed_amount"])
+}).optional();
+var PostPurchaseProductChangeset = import_zod71.z.object({
+  changes: import_zod71.z.array(
+    import_zod71.z.union([
+      import_zod71.z.object({
+        discount: ChangesetDiscount,
+        quantity: import_zod71.z.number().int().positive(),
+        type: import_zod71.z.literal("add_variant"),
+        variantId: import_zod71.z.number().int().positive()
+      }),
+      import_zod71.z.object({ price: import_zod71.z.number().nonnegative(), title: import_zod71.z.string(), type: import_zod71.z.literal("add_shipping_line") }),
+      PostPurchaseSubscriptionTerms.pick({
+        initialShippingPrice: true,
+        recurringShippingPrice: true,
+        shippingOption: true
+      }).extend({
+        discount: ChangesetDiscount,
+        quantity: import_zod71.z.number().int().positive(),
+        sellingPlanId: import_zod71.z.number().int().positive(),
+        type: import_zod71.z.literal("add_subscription"),
+        variantId: import_zod71.z.number().int().positive()
+      })
+    ])
+  )
+});
+
 // src/schema/postPurchaseProductView.ts
-var PostPurchaseProductView = import_zod67.z.union([
-  import_zod67.z.object({
+var PostPurchaseProductView = import_zod72.z.union([
+  import_zod72.z.object({
+    changeset: PostPurchaseProductChangeset.optional(),
+    displayPrice: PostPurchaseDisplayPrice.optional(),
     groupCatalog: PostPurchaseGroupCatalog.optional(),
     initialVariant: PostPurchaseVariantSelector.optional(),
     planCatalog: PostPurchasePlanCatalog.nullable().optional(),
     preparation: PreparedPostPurchaseProduct.extend({
-      display: PreparedPostPurchaseProduct.shape.display.extend({ description: import_zod67.z.string().nullable() }).refine(
+      display: PreparedPostPurchaseProduct.shape.display.extend({ description: import_zod72.z.string().nullable() }).refine(
         ({ description, descriptionDocument }) => description === null === (descriptionDocument !== void 0),
         "Exactly one of the plain and rich descriptions is shown"
       )
@@ -6550,24 +6892,26 @@ var PostPurchaseProductView = import_zod67.z.union([
     sections: CABRootSection,
     variantCatalog: PostPurchaseVariantCatalog.optional()
   }),
-  import_zod67.z.object({
+  import_zod72.z.object({
     groupCatalog: PostPurchaseGroupCatalog.optional(),
     initialVariant: PostPurchaseVariantSelector.optional(),
+    /** The localized unavailable copy, for the choices still offered beneath an unprepared product. */
+    labels: PreparedPostPurchaseProduct.shape.labels.pick({ notAvailable: true }).optional(),
     planCatalog: PostPurchasePlanCatalog.nullable().optional(),
     preparation: PostPurchasePreparation.options[1],
     purchaseOptions: PostPurchaseOptions.optional(),
-    sections: import_zod67.z.null(),
+    sections: import_zod72.z.null(),
     variantCatalog: PostPurchaseVariantCatalog.optional()
   })
 ]);
 
 // src/server/postPurchaseOfferCopy.ts
-var import_zod68 = require("zod");
-var Copy = import_zod68.z.object({
+var import_zod73 = require("zod");
+var Copy = import_zod73.z.object({
   superTitle: CalloutBannerBlock.shape.settings.shape.superTitle.unwrap().optional().catch(void 0),
   title: CalloutBannerBlock.shape.settings.shape.title.unwrap().optional().catch(void 0)
 });
-var Callout = import_zod68.z.object({ settings: import_zod68.z.record(import_zod68.z.string(), import_zod68.z.unknown()), type: import_zod68.z.literal("callout_banner") });
+var Callout = import_zod73.z.object({ settings: import_zod73.z.record(import_zod73.z.string(), import_zod73.z.unknown()), type: import_zod73.z.literal("callout_banner") });
 var postPurchaseOfferCopy = (blocks, metadata) => {
   const copy = Copy.safeParse(metadata.widget.language);
   if (!blocks || !copy.success) return blocks;
@@ -6588,13 +6932,13 @@ var postPurchaseOfferCopy = (blocks, metadata) => {
 };
 
 // src/server/selectPostPurchaseChoice.ts
-var selectPostPurchaseChoice = (normalized, projected, requested, allowCollection, quantity2) => {
+var selectPostPurchaseChoice = (normalized, projected, requested, allowCollection, quantity3) => {
   const { data, effective } = normalized;
   const modes = [];
   const catalog = projected && projected.productId === data[0]?.id && projected.variantId === data[0].variants[0]?.id ? projected : null;
   const firstPlan = catalog?.plans[0];
-  const oneTimeReason = oneTimeUnavailable(normalized, allowCollection, quantity2);
-  const subscriptionReason = subscriptionUnavailable(normalized, firstPlan, allowCollection, quantity2);
+  const oneTimeReason = oneTimeUnavailable(normalized, allowCollection, quantity3);
+  const subscriptionReason = subscriptionUnavailable(normalized, firstPlan, allowCollection, quantity3);
   if (!oneTimeReason) modes.push("one-time");
   if (!subscriptionReason) modes.push("subscription");
   if (oneTimeReason && subscriptionReason)
@@ -6622,22 +6966,26 @@ var resolveDescription = ({ descriptionDocument, ...display }, productDescriptio
   const plain = display.language.descriptionEnabled && productDescription || display.responseDescription || (descriptionDocument ? null : display.language.description);
   return plain === null ? { ...display, description: null, descriptionDocument } : { ...display, description: plain };
 };
-var prepareNormalizedPostPurchaseView = (widgetId, normalized, report, choice, quantity2, allowCollection = false) => {
+var prepareNormalizedPostPurchaseView = (widgetId, normalized, report, choice, quantity3, allowCollection = false) => {
   const planCatalog = projectPostPurchasePlanCatalog(normalized, report);
-  const selected = selectPostPurchaseChoice(normalized, planCatalog, choice, allowCollection, quantity2);
+  const selected = selectPostPurchaseChoice(normalized, planCatalog, choice, allowCollection, quantity3);
   const purchaseOptions = selected.options;
-  const preparation = !selected.choice ? { reason: selected.reason, status: "unsupported" } : selected.choice.mode === "subscription" ? prepareNormalizedSubscription(normalized, report, selected.plan, quantity2, allowCollection) : prepareNormalizedProduct(normalized, report, quantity2, allowCollection);
+  const labels = { notAvailable: normalized.effective.language.global.notAvailable };
+  const preparation = !selected.choice ? { reason: selected.reason, status: "unsupported" } : selected.choice.mode === "subscription" ? prepareNormalizedSubscription(normalized, report, selected.plan, quantity3, allowCollection) : prepareNormalizedProduct(normalized, report, quantity3, allowCollection);
   const unsupported = (reason) => ({
+    labels,
     planCatalog,
     preparation: { reason, status: "unsupported" },
     purchaseOptions,
     sections: null
   });
-  if (preparation.status === "unsupported") return { planCatalog, preparation, purchaseOptions, sections: null };
+  if (preparation.status === "unsupported")
+    return { labels, planCatalog, preparation, purchaseOptions, sections: null };
   if (!normalized.effective.blocks?.length) return unsupported("One fixed product information block is required");
   const sections = convertMessagePreview(
     widgetId,
     {
+      ...normalized.effective,
       blocks: postPurchaseOfferCopy(normalized.effective.blocks, normalized.metadata),
       type: "shopify_post_purchase_extension"
     },
@@ -6666,154 +7014,102 @@ var preparePostPurchaseAdmissionView = (widgetId, settings, response, report, ch
 };
 
 // src/schema/postPurchaseProductCollectionView.ts
-var import_zod76 = require("zod");
+var import_zod80 = require("zod");
 
 // src/schema/postPurchaseProgress.ts
-var import_zod75 = require("zod");
+var import_zod79 = require("zod");
 
 // src/schema/postPurchaseDeclineDelivery.ts
-var import_zod74 = require("zod");
+var import_zod78 = require("zod");
 
 // src/schema/postPurchaseAcceptedEvent.ts
-var import_zod73 = require("zod");
+var import_zod77 = require("zod");
 
 // src/schema/postPurchaseAdmission.ts
-var import_zod72 = require("zod");
+var import_zod76 = require("zod");
 
 // src/schema/postPurchaseIdentity.ts
-var import_zod69 = require("zod");
+var import_zod74 = require("zod");
 var POST_PURCHASE_ID_MAX = 128;
-var PostPurchaseTimestampSchema = import_zod69.z.number().int().nonnegative();
-var PostPurchaseOrderIdSchema = import_zod69.z.string().regex(/^gid:\/\/shopify\/Order\/[1-9]\d*$/);
-var ShopifyDomainSchema = import_zod69.z.string().max(POST_PURCHASE_ID_MAX).regex(/^[a-z0-9]([a-z0-9-]*[a-z0-9])?\.myshopify\.com$/);
-var DecideRequestSchema = import_zod69.z.object({
-  checkoutToken: import_zod69.z.string().min(1).max(POST_PURCHASE_ID_MAX),
+var PostPurchaseTimestampSchema = import_zod74.z.number().int().nonnegative();
+var PostPurchaseOrderIdSchema = import_zod74.z.string().regex(/^gid:\/\/shopify\/Order\/[1-9]\d*$/);
+var ShopifyDomainSchema = import_zod74.z.string().max(POST_PURCHASE_ID_MAX).regex(/^[a-z0-9]([a-z0-9-]*[a-z0-9])?\.myshopify\.com$/);
+var DecideRequestSchema = import_zod74.z.object({
+  checkoutToken: import_zod74.z.string().min(1).max(POST_PURCHASE_ID_MAX),
   shop: ShopifyDomainSchema
 });
-var PostPurchaseAppIdSchema = import_zod69.z.string().min(1).max(POST_PURCHASE_ID_MAX);
-var DecisionEntrySchema = import_zod69.z.object({
-  blockId: import_zod69.z.number().int().positive(),
-  blockIndex: import_zod69.z.string(),
-  blockParentIndex: import_zod69.z.string(),
-  flowId: import_zod69.z.number().int().positive(),
-  sectionId: import_zod69.z.number().int().positive(),
-  widgetId: import_zod69.z.number().int().positive(),
-  widgetTraffic: import_zod69.z.number().min(0).max(100)
+var PostPurchaseAppIdSchema = import_zod74.z.string().min(1).max(POST_PURCHASE_ID_MAX);
+var DecisionEntrySchema = import_zod74.z.object({
+  blockId: import_zod74.z.number().int().positive(),
+  blockIndex: import_zod74.z.string(),
+  blockParentIndex: import_zod74.z.string(),
+  flowId: import_zod74.z.number().int().positive(),
+  sectionId: import_zod74.z.number().int().positive(),
+  widgetId: import_zod74.z.number().int().positive(),
+  widgetTraffic: import_zod74.z.number().min(0).max(100)
 });
 
 // src/schema/postPurchaseMemberIdentity.ts
-var import_zod70 = require("zod");
-var PostPurchaseMemberIdentity = import_zod70.z.object({
-  productId: import_zod70.z.number().int().positive(),
-  productIndex: import_zod70.z.number().int().nonnegative()
+var import_zod75 = require("zod");
+var PostPurchaseMemberIdentity = import_zod75.z.object({
+  productId: import_zod75.z.number().int().positive(),
+  productIndex: import_zod75.z.number().int().nonnegative()
 }).strict();
 
-// src/schema/postPurchaseProductCalculation.ts
-var import_zod71 = require("zod");
-var MoneyBag = import_zod71.z.object({
-  presentmentMoney: import_zod71.z.object({
-    amount: PostPurchaseAmount,
-    currencyCode: import_zod71.z.string().regex(/^[A-Z]{3}$/)
-  })
-});
-var PostPurchaseProductCalculation = import_zod71.z.object({
-  calculatedPurchase: import_zod71.z.object({
-    addedShippingLines: import_zod71.z.array(import_zod71.z.object({ priceSet: MoneyBag })),
-    addedTaxLines: import_zod71.z.array(import_zod71.z.object({ priceSet: MoneyBag })),
-    totalOutstandingSet: MoneyBag,
-    updatedLineItems: import_zod71.z.array(
-      import_zod71.z.object({
-        priceSet: import_zod71.z.unknown().optional(),
-        productId: import_zod71.z.number().int().positive(),
-        sellingPlanId: import_zod71.z.unknown().optional(),
-        variantId: import_zod71.z.number().int().positive()
-      })
-    )
-  }),
-  errors: import_zod71.z.array(import_zod71.z.unknown()).length(0),
-  status: import_zod71.z.literal("processed")
-});
-var Minor = import_zod71.z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
-var PostPurchaseProductCosts = import_zod71.z.object({
-  currencyCode: MoneyBag.shape.presentmentMoney.shape.currencyCode,
-  recurringDisplay: import_zod71.z.object({ shippingMinor: Minor, subtotalMinor: Minor, totalMinor: Minor }).optional(),
-  shippingMinor: Minor,
-  subtotalMinor: Minor,
-  taxesMinor: Minor,
-  totalMinor: Minor
-});
-var ChangesetDiscount = import_zod71.z.object({
-  title: import_zod71.z.string(),
-  value: import_zod71.z.number().nonnegative(),
-  valueType: import_zod71.z.enum(["percentage", "fixed_amount"])
-}).optional();
-var PostPurchaseProductChangeset = import_zod71.z.object({
-  changes: import_zod71.z.array(
-    import_zod71.z.union([
-      import_zod71.z.object({
-        discount: ChangesetDiscount,
-        quantity: import_zod71.z.number().int().positive(),
-        type: import_zod71.z.literal("add_variant"),
-        variantId: import_zod71.z.number().int().positive()
-      }),
-      import_zod71.z.object({ price: import_zod71.z.number().nonnegative(), title: import_zod71.z.string(), type: import_zod71.z.literal("add_shipping_line") }),
-      PostPurchaseSubscriptionTerms.pick({
-        initialShippingPrice: true,
-        recurringShippingPrice: true,
-        shippingOption: true
-      }).extend({
-        discount: ChangesetDiscount,
-        quantity: import_zod71.z.number().int().positive(),
-        sellingPlanId: import_zod71.z.number().int().positive(),
-        type: import_zod71.z.literal("add_subscription"),
-        variantId: import_zod71.z.number().int().positive()
-      })
-    ])
-  )
-});
-
 // src/schema/postPurchaseAdmission.ts
-var PurchaseExpectedSchema = import_zod72.z.object({
-  buyerConsentToSubscriptions: import_zod72.z.boolean().optional(),
+var PurchaseAdmissionModeSchema = import_zod76.z.enum(["purchase", "upgrade"]);
+var selection = PreparedPostPurchaseProduct.shape.selection;
+var PurchaseExpectedSchema = import_zod76.z.object({
+  buyerConsentToSubscriptions: import_zod76.z.boolean().optional(),
   changeset: PostPurchaseProductChangeset.extend({
     changes: PostPurchaseProductChangeset.shape.changes.min(1).max(2)
   }),
   entry: DecisionEntrySchema,
   member: PostPurchaseMemberIdentity.optional(),
-  progressRevision: import_zod72.z.number().int().nonnegative().optional(),
-  selection: PreparedPostPurchaseProduct.shape.selection
+  mode: PurchaseAdmissionModeSchema.optional(),
+  progressRevision: import_zod76.z.number().int().nonnegative().optional(),
+  selection
 }).refine(
   ({ member, progressRevision }) => !member || progressRevision !== void 0,
   "Captured member requires progress"
-).refine(({ buyerConsentToSubscriptions: consent, changeset, selection: selection3 }) => {
+).refine(
+  ({ mode, selection: { sellingPlanId } }) => mode !== "upgrade" || sellingPlanId !== void 0,
+  "An upgrade selects a subscription"
+).refine(({ buyerConsentToSubscriptions: consent, changeset, selection: selection4 }) => {
   const [change, shipping] = changeset.changes;
-  if (selection3.sellingPlanId === void 0)
-    return consent !== true && change?.type === "add_variant" && change.variantId === selection3.variantId && change.quantity === selection3.quantity && (shipping === void 0 || shipping.type === "add_shipping_line");
-  return consent === true && changeset.changes.length === 1 && change.type === "add_subscription" && change.sellingPlanId === selection3.sellingPlanId && change.variantId === selection3.variantId && change.quantity === selection3.quantity;
+  if (selection4.sellingPlanId === void 0)
+    return consent !== true && change?.type === "add_variant" && change.variantId === selection4.variantId && change.quantity === selection4.quantity && (shipping === void 0 || shipping.type === "add_shipping_line");
+  return consent === true && changeset.changes.length === 1 && change.type === "add_subscription" && change.sellingPlanId === selection4.sellingPlanId && change.variantId === selection4.variantId && change.quantity === selection4.quantity;
 }, "Selection, change and buyer consent must agree");
 var PurchaseRequestSchema = DecideRequestSchema.extend({
   expected: PurchaseExpectedSchema,
-  requestId: import_zod72.z.uuid()
+  requestId: import_zod76.z.uuid()
 }).strict();
-var PurchaseReceiptSchema = import_zod72.z.object({
+var PurchaseReceiptSchema = import_zod76.z.object({
   admittedAt: PostPurchaseTimestampSchema,
-  changesetToken: import_zod72.z.string().min(1),
-  operationId: import_zod72.z.uuid(),
-  requiresSubscriptionConsent: import_zod72.z.boolean(),
-  selection: PreparedPostPurchaseProduct.shape.selection
+  changesetToken: import_zod76.z.string().min(1),
+  mode: PurchaseAdmissionModeSchema.optional(),
+  operationId: import_zod76.z.uuid(),
+  /** The server-bound one-time line an upgrade refunds; its quantity is the order's, not the selection's. */
+  originalLine: import_zod76.z.strictObject({ quantity: selection.shape.quantity, variantId: selection.shape.variantId }).optional(),
+  requiresSubscriptionConsent: import_zod76.z.boolean(),
+  selection
 }).refine(
-  ({ requiresSubscriptionConsent, selection: selection3 }) => requiresSubscriptionConsent === (selection3.sellingPlanId !== void 0),
+  ({ requiresSubscriptionConsent, selection: selection4 }) => requiresSubscriptionConsent === (selection4.sellingPlanId !== void 0),
   "Receipt consent must match its selected plan"
+).refine(
+  ({ mode, originalLine, selection: { sellingPlanId, variantId } }) => mode === "upgrade" ? sellingPlanId !== void 0 && originalLine?.variantId === variantId : originalLine === void 0,
+  "An upgrade Receipt binds the original line of its subscribed variant, and only an upgrade does"
 );
-var PurchaseResponseSchema = import_zod72.z.object({ data: PurchaseReceiptSchema, successful: import_zod72.z.literal(true) });
+var PurchaseResponseSchema = import_zod76.z.object({ data: PurchaseReceiptSchema, successful: import_zod76.z.literal(true) });
 
 // src/schema/postPurchaseAcceptedEvent.ts
 var EventCalculationSchema = PostPurchaseProductCosts.pick({ currencyCode: true, totalMinor: true }).strict();
-var AcceptedEventOutcomeSchema = import_zod73.z.enum(["acknowledged", "rejected", "skipped", "unknown"]);
-var AttemptProgressSchema = import_zod73.z.strictObject({
+var AcceptedEventOutcomeSchema = import_zod77.z.enum(["acknowledged", "rejected", "skipped", "unknown"]);
+var AttemptProgressSchema = import_zod77.z.strictObject({
   attemptedAt: PostPurchaseTimestampSchema,
   reportedCalculation: EventCalculationSchema,
-  status: import_zod73.z.literal("attempted")
+  status: import_zod77.z.literal("attempted")
 });
 var AcceptedEventAttemptProgressSchema = AttemptProgressSchema.extend({
   operationId: PurchaseReceiptSchema.shape.operationId
@@ -6826,17 +7122,17 @@ var AcceptedEventRequestSchema = DecideRequestSchema.extend({
   operationId: PurchaseReceiptSchema.shape.operationId,
   reportedCalculation: EventCalculationSchema
 }).strict();
-var AcceptedEventResponseSchema = import_zod73.z.object({
-  data: import_zod73.z.union([AcceptedEventAttemptProgressSchema, AcceptedEventResultProgressSchema]),
-  successful: import_zod73.z.literal(true)
+var AcceptedEventResponseSchema = import_zod77.z.object({
+  data: import_zod77.z.union([AcceptedEventAttemptProgressSchema, AcceptedEventResultProgressSchema]),
+  successful: import_zod77.z.literal(true)
 });
 
 // src/schema/postPurchaseDeclineDelivery.ts
-var AttemptSchema = import_zod74.z.strictObject({
+var AttemptSchema = import_zod78.z.strictObject({
   attemptedAt: PostPurchaseTimestampSchema,
-  status: import_zod74.z.enum(["attempted", "unavailable"])
+  status: import_zod78.z.enum(["attempted", "unavailable"])
 });
-var DeclineDeliveryProgressSchema = import_zod74.z.union([
+var DeclineDeliveryProgressSchema = import_zod78.z.union([
   AttemptSchema,
   AttemptSchema.extend({
     finishedAt: PostPurchaseTimestampSchema,
@@ -6845,36 +7141,36 @@ var DeclineDeliveryProgressSchema = import_zod74.z.union([
 ]);
 
 // src/schema/postPurchaseProgress.ts
-var PostPurchaseProgressSchema = import_zod75.z.object({
+var PostPurchaseProgressSchema = import_zod79.z.object({
   closedAt: PostPurchaseTimestampSchema.nullable(),
   deadline: PostPurchaseTimestampSchema,
   entry: DecisionEntrySchema,
-  entryRevision: import_zod75.z.number().int().nonnegative(),
-  members: import_zod75.z.array(
+  entryRevision: import_zod79.z.number().int().nonnegative(),
+  members: import_zod79.z.array(
     PostPurchaseMemberIdentity.extend({
       declineDelivery: DeclineDeliveryProgressSchema.optional(),
-      status: import_zod75.z.enum(["unhandled", "accepted", "declined"])
+      status: import_zod79.z.enum(["unhandled", "accepted", "declined"])
     }).strict()
   ),
-  revision: import_zod75.z.number().int().nonnegative()
+  revision: import_zod79.z.number().int().nonnegative()
 }).strict();
 
 // src/schema/postPurchaseProductCollectionView.ts
-var PostPurchaseProductCollectionView = import_zod76.z.object({
-  members: import_zod76.z.array(
-    import_zod76.z.object({
+var PostPurchaseProductCollectionView = import_zod80.z.object({
+  members: import_zod80.z.array(
+    import_zod80.z.object({
       productId: PostPurchaseProductId,
-      productIndex: import_zod76.z.number().int().nonnegative(),
+      productIndex: import_zod80.z.number().int().nonnegative(),
       view: PostPurchaseProductView
     })
   )
 });
-var PostPurchaseCollectionChoice = import_zod76.z.object({
+var PostPurchaseCollectionChoice = import_zod80.z.object({
   choice: PostPurchaseChoice.optional(),
   productId: PostPurchaseProductId,
   variantId: PostPurchaseVariantSelector.shape.variantId.optional()
 }).strict();
-var PostPurchaseExcludedProductIds = import_zod76.z.array(PostPurchaseProductId).default([]);
+var PostPurchaseExcludedProductIds = import_zod80.z.array(PostPurchaseProductId).default([]);
 var PostPurchaseMemberSelector = PostPurchaseProgressSchema.shape.members.element.pick({ productId: true }).extend({ progressRevision: PostPurchaseProgressSchema.shape.revision });
 var PostPurchaseMemberPointer = PostPurchaseProgressSchema.shape.members.element.omit({ status: true }).extend({
   entryRevision: PostPurchaseProgressSchema.shape.entryRevision,
@@ -6882,10 +7178,10 @@ var PostPurchaseMemberPointer = PostPurchaseProgressSchema.shape.members.element
 });
 
 // src/server/normalizePostPurchaseCollection.ts
-var import_zod77 = require("zod");
+var import_zod81 = require("zod");
 var normalizePostPurchaseCollection = (settings, response, excludedProductIds) => {
   const normalized = normalizePostPurchaseProduct(settings, response);
-  const limit = import_zod77.z.number().int().positive();
+  const limit = import_zod81.z.number().int().positive();
   limit.parse(normalized.original.productLimit);
   const prefix = normalized.data.slice(0, limit.parse(normalized.effective.productLimit));
   if (new Set(prefix.map(({ id }) => id)).size !== prefix.length)
@@ -6929,13 +7225,13 @@ var projectPostPurchaseVariantCatalog = (product, settings) => {
 };
 
 // src/schema/postPurchaseQuantity.ts
-var import_zod78 = require("zod");
-var quantity = PreparedPostPurchaseProduct.shape.selection.shape.quantity;
-var PostPurchaseQuantityChoice = PostPurchaseCollectionChoice.extend({ quantity: quantity.optional() });
+var import_zod82 = require("zod");
+var quantity2 = PreparedPostPurchaseProduct.shape.selection.shape.quantity;
+var PostPurchaseQuantityChoice = PostPurchaseCollectionChoice.extend({ quantity: quantity2.optional() });
 var PostPurchaseQuantityPolicy = PostPurchaseSettings.shape.quantityInputs.omit({ defaultQuantity: true }).extend({
-  initialQuantity: quantity,
-  maxValue: quantity,
-  minValue: import_zod78.z.literal(0).transform(() => 1).or(quantity)
+  initialQuantity: quantity2,
+  maxValue: quantity2,
+  minValue: import_zod82.z.literal(0).transform(() => 1).or(quantity2)
 }).refine(({ maxValue, minValue }) => minValue <= maxValue, "Quantity bounds are reversed");
 
 // src/server/readPostPurchaseQuantity.ts
@@ -6945,7 +7241,7 @@ var readPostPurchaseQuantity = ({
   data,
   effective,
   original
-}, selection3) => {
+}, selection4) => {
   const positive = PreparedPostPurchaseProduct.shape.selection.shape.quantity;
   for (const config of [original, effective]) {
     if (!config.quantityInputs.enabled) continue;
@@ -6958,47 +7254,47 @@ var readPostPurchaseQuantity = ({
   const policy = PostPurchaseQuantityPolicy.parse(
     effective.quantityInputs.enabled ? { ...effective.quantityInputs, initialQuantity } : { enabled: false, initialQuantity, maxValue: initialQuantity, minValue: initialQuantity }
   );
-  const requested = "quantity" in selection3 ? selection3.quantity : selection3.expectedQuantity === initialQuantity ? void 0 : selection3.expectedQuantity;
-  const quantity2 = positive.parse(requested ?? initialQuantity);
-  if (requested !== void 0 && (policy.enabled ? quantity2 < policy.minValue || quantity2 > policy.maxValue : quantity2 !== initialQuantity))
+  const requested = "quantity" in selection4 ? selection4.quantity : selection4.expectedQuantity === initialQuantity ? void 0 : selection4.expectedQuantity;
+  const quantity3 = positive.parse(requested ?? initialQuantity);
+  if (requested !== void 0 && (policy.enabled ? quantity3 < policy.minValue || quantity3 > policy.maxValue : quantity3 !== initialQuantity))
     throw new PostPurchaseQuantityUnavailable("Requested quantity is unavailable");
-  return { policy, quantity: quantity2 };
+  return { policy, quantity: quantity3 };
 };
 
 // src/schema/postPurchaseVariantDefault.ts
-var import_zod79 = require("zod");
+var import_zod83 = require("zod");
 var values = PostPurchaseVariantValues.partial().extend({
   option1: PostPurchaseVariantValues.shape.option1.nullish()
 });
 var variant = values.extend({
   id: PostPurchaseVariantId,
-  inventoryManagement: import_zod79.z.string().nullable(),
-  inventoryPolicy: import_zod79.z.string(),
-  inventoryQuantity: import_zod79.z.number()
+  inventoryManagement: import_zod83.z.string().nullable(),
+  inventoryPolicy: import_zod83.z.string(),
+  inventoryQuantity: import_zod83.z.number()
 });
-var options = import_zod79.z.array(PostPurchaseVariantOption.pick({ name: true, values: true }));
-var PostPurchaseVariantDefaultProduct = import_zod79.z.object({
+var options = import_zod83.z.array(PostPurchaseVariantOption.pick({ name: true, values: true }));
+var PostPurchaseVariantDefaultProduct = import_zod83.z.object({
   id: PostPurchaseProductId,
   options,
   selectedVariant: variant.optional(),
-  variants: import_zod79.z.array(variant)
+  variants: import_zod83.z.array(variant)
 });
 var PostPurchaseVariantDefaultSettings = PostPurchaseSettings.shape.productOptions.pick({
   hideOutOfStockVariants: true,
   matchVariant: true
 });
-var PostPurchaseOrderAttributes = import_zod79.z.record(import_zod79.z.string(), import_zod79.z.array(import_zod79.z.string())).default({});
-var PostPurchaseOriginalVariants = import_zod79.z.array(
-  import_zod79.z.object({ productId: PostPurchaseProductId, variantId: PostPurchaseVariantId })
+var PostPurchaseOrderAttributes = import_zod83.z.record(import_zod83.z.string(), import_zod83.z.array(import_zod83.z.string())).default({});
+var PostPurchaseOriginalVariants = import_zod83.z.array(
+  import_zod83.z.object({ productId: PostPurchaseProductId, variantId: PostPurchaseVariantId })
 );
-var PostPurchaseAttributeProducts = import_zod79.z.array(
-  import_zod79.z.object({ id: PostPurchaseProductId, options, variants: import_zod79.z.array(values.extend({ id: PostPurchaseVariantId })) })
+var PostPurchaseAttributeProducts = import_zod83.z.array(
+  import_zod83.z.object({ id: PostPurchaseProductId, options, variants: import_zod83.z.array(values.extend({ id: PostPurchaseVariantId })) })
 );
 
 // src/schema/postPurchaseVariantDefaultContext.ts
-var import_zod80 = require("zod");
-var PostPurchaseVariantDefaultContext = import_zod80.z.object({
-  enrichedLineItems: import_zod80.z.unknown().optional(),
+var import_zod84 = require("zod");
+var PostPurchaseVariantDefaultContext = import_zod84.z.object({
+  enrichedLineItems: import_zod84.z.unknown().optional(),
   originalVariants: PostPurchaseOriginalVariants
 });
 
@@ -7084,13 +7380,13 @@ var prepareMember = (widgetId, settings, response, requested, report, excludedPr
     variants: found.product.variants.filter(({ id }) => id === variantId)
   };
   const selectedInput = { ...normalized, data: [product] };
-  const quantity2 = requestedQuantity ? readPostPurchaseQuantity(selectedInput, requestedQuantity) : void 0;
-  const view = prepareNormalizedPostPurchaseView(widgetId, selectedInput, report, selected.choice, quantity2, true);
+  const quantity3 = requestedQuantity ? readPostPurchaseQuantity(selectedInput, requestedQuantity) : void 0;
+  const view = prepareNormalizedPostPurchaseView(widgetId, selectedInput, report, selected.choice, quantity3, true);
   if (selected.variantId !== void 0 || found.product.variants.length > 1)
     view.variantCatalog = projectPostPurchaseVariantCatalog(found.product, normalized.effective);
   if (defaults && selected.variantId === void 0 && variantId && view.variantCatalog?.variants.some(({ id }) => id === variantId))
     view.initialVariant = { variantId };
-  return { member: { productId: found.product.id, productIndex: found.productIndex, view }, normalized, quantity: quantity2 };
+  return { member: { productId: found.product.id, productIndex: found.productIndex, view }, normalized, quantity: quantity3 };
 };
 var preparePostPurchaseMemberView = (widgetId, settings, response, requested, report, excludedProductIds) => prepareMember(widgetId, settings, response, requested, report, excludedProductIds)?.member ?? null;
 var preparePostPurchaseMemberAdmissionView = (widgetId, settings, response, requested, report, excludedProductIds) => {
@@ -7102,24 +7398,24 @@ var preparePostPurchaseMemberAdmissionView = (widgetId, settings, response, requ
 
 // src/server/preparePostPurchaseQuantityView.ts
 var preparePostPurchaseQuantityView = (widgetId, settings, response, requested, report, excludedProductIds, defaults) => {
-  const { quantity: quantity2, ...selection3 } = PostPurchaseQuantityChoice.parse(requested);
+  const { quantity: quantity3, ...selection4 } = PostPurchaseQuantityChoice.parse(requested);
   const prepared = prepareMember(
     widgetId,
     settings,
     response,
-    selection3,
+    selection4,
     report,
     excludedProductIds,
-    { quantity: quantity2 },
+    { quantity: quantity3 },
     defaults
   );
   return prepared ? { ...prepared.member, quantityPolicy: prepared.quantity.policy } : null;
 };
 
 // src/server/preparePostPurchaseQuantityAdmissionView.ts
-var selection = PostPurchaseQuantityChoice.required({ quantity: true });
+var selection2 = PostPurchaseQuantityChoice.required({ quantity: true });
 var preparePostPurchaseQuantityAdmissionView = (widgetId, settings, response, expected, report, excludedProductIds, defaults) => {
-  const { quantity: expectedQuantity, ...requested } = selection.parse(expected);
+  const { quantity: expectedQuantity, ...requested } = selection2.parse(expected);
   const prepared = prepareMember(
     widgetId,
     settings,
@@ -7172,12 +7468,12 @@ var readPostPurchaseGroup = (product, settings, excludedProductIds) => {
 
 // src/server/readPostPurchaseGroupSelection.ts
 var readPostPurchaseGroupSelection = (settings, response, requested, excludedProductIds) => {
-  const selection3 = PostPurchaseGroupSelection.parse(requested);
+  const selection4 = PostPurchaseGroupSelection.parse(requested);
   const { members, normalized } = normalizePostPurchaseCollection(settings, response);
-  const member = members.find(({ product }) => product.id === selection3.memberProductId);
+  const member = members.find(({ product }) => product.id === selection4.memberProductId);
   if (!member || !member.product.productGroupVariants.length) return null;
   const group = readPostPurchaseGroup(member.product, normalized.effective, excludedProductIds);
-  const entry = group.entries.find(({ product }) => product.id === selection3.productId);
+  const entry = group.entries.find(({ product }) => product.id === selection4.productId);
   if (!entry) return null;
   return {
     groupCatalog: group.catalog,
@@ -7191,16 +7487,16 @@ var readPostPurchaseGroupSelection = (settings, response, requested, excludedPro
 
 // src/server/preparePostPurchaseGroupView.ts
 var preparePostPurchaseGroupView = (widgetId, settings, response, requested, report, excludedProductIds) => {
-  const { memberProductId, ...selection3 } = PostPurchaseGroupChoice.parse(requested);
+  const { memberProductId, ...selection4 } = PostPurchaseGroupChoice.parse(requested);
   const group = readPostPurchaseGroupSelection(settings, response, requested, excludedProductIds);
   if (!group) return null;
-  const variantId = selection3.variantId ?? group.variantCatalog.variants.find(({ available }) => available)?.id;
+  const variantId = selection4.variantId ?? group.variantCatalog.variants.find(({ available }) => available)?.id;
   if (variantId === void 0) return null;
   const prepared = preparePostPurchaseQuantityView(
     widgetId,
     settings,
     group.response,
-    { ...selection3, variantId },
+    { ...selection4, variantId },
     report
   );
   return prepared && {
@@ -7214,16 +7510,16 @@ var preparePostPurchaseGroupView = (widgetId, settings, response, requested, rep
 
 // src/server/preparePostPurchaseGroupAdmissionView.ts
 var preparePostPurchaseGroupAdmissionView = (widgetId, settings, response, requested, report, excludedProductIds) => {
-  const { memberProductId, ...selection3 } = PostPurchaseGroupChoice.required({ quantity: true }).parse(requested);
+  const { memberProductId, ...selection4 } = PostPurchaseGroupChoice.required({ quantity: true }).parse(requested);
   const group = readPostPurchaseGroupSelection(settings, response, requested, excludedProductIds);
   if (!group) return null;
-  const variantId = selection3.variantId ?? group.variantCatalog.variants.find(({ available }) => available)?.id;
+  const variantId = selection4.variantId ?? group.variantCatalog.variants.find(({ available }) => available)?.id;
   if (variantId === void 0) return null;
   const prepared = preparePostPurchaseQuantityAdmissionView(
     widgetId,
     settings,
     group.response,
-    { ...selection3, variantId },
+    { ...selection4, variantId },
     report
   );
   return prepared && {
@@ -7286,6 +7582,7 @@ var preparePostPurchaseCollectionGroup = (widgetId, settings, response, member,
     reportingProduct: { id: member.product.id, title: member.product.title },
     view: prepared ? { ...prepared.view, groupCatalog: prepared.groupCatalog } : {
       groupCatalog: group.catalog,
+      labels: { notAvailable: normalized.effective.language.global.notAvailable },
       preparation: { reason: "Post-purchase group default is unavailable", status: "unsupported" },
       sections: null
     }
@@ -7341,22 +7638,22 @@ var preparePostPurchaseCollectionView = (widgetId, settings, response, report, r
 };
 
 // src/schema/postPurchaseOfferEligibility.ts
-var import_zod81 = require("zod");
-var selection2 = PreparedPostPurchaseProduct.shape.selection;
-var PostPurchaseOfferSkipReason = import_zod81.z.enum(["empty", "no-eligible-subscription"]);
-var PostPurchaseOfferEligibilityContext = import_zod81.z.object({
+var import_zod85 = require("zod");
+var selection3 = PreparedPostPurchaseProduct.shape.selection;
+var PostPurchaseOfferSkipReason = import_zod85.z.enum(["empty", "no-eligible-subscription"]);
+var PostPurchaseOfferEligibilityContext = import_zod85.z.object({
   excludedProductIds: PostPurchaseExcludedProductIds,
-  originalLineItems: import_zod81.z.array(selection2.pick({ productId: true, sellingPlanId: true, variantId: true }))
+  originalLineItems: import_zod85.z.array(selection3.pick({ productId: true, sellingPlanId: true, variantId: true }))
 });
-var PostPurchaseOfferEligibility = import_zod81.z.discriminatedUnion("status", [
-  import_zod81.z.object({
-    members: import_zod81.z.array(
-      import_zod81.z.object({ productId: selection2.shape.productId, productIndex: import_zod81.z.number().int().nonnegative() })
+var PostPurchaseOfferEligibility = import_zod85.z.discriminatedUnion("status", [
+  import_zod85.z.object({
+    members: import_zod85.z.array(
+      import_zod85.z.object({ productId: selection3.shape.productId, productIndex: import_zod85.z.number().int().nonnegative() })
     ),
-    status: import_zod81.z.literal("retain")
+    status: import_zod85.z.literal("retain")
   }),
-  import_zod81.z.object({ reason: PostPurchaseOfferSkipReason, status: import_zod81.z.literal("skip") }),
-  import_zod81.z.object({ reason: import_zod81.z.literal("eligible-upgrade").optional(), status: import_zod81.z.literal("unavailable") })
+  import_zod85.z.object({ reason: PostPurchaseOfferSkipReason, status: import_zod85.z.literal("skip") }),
+  import_zod85.z.object({ reason: import_zod85.z.literal("eligible-upgrade").optional(), status: import_zod85.z.literal("unavailable") })
 ]);
 
 // src/server/postPurchaseMemberEligibility.ts
@@ -7435,10 +7732,10 @@ var classifyPostPurchaseOffer = (settings, response, context) => {
 };
 
 // src/server/preparePostPurchaseDeclineDisplay.ts
-var import_zod83 = require("zod");
+var import_zod87 = require("zod");
 
 // src/schema/postPurchaseDecline.ts
-var import_zod82 = require("zod");
+var import_zod86 = require("zod");
 var OfferDeclineRequestSchema = DecideRequestSchema.extend({
   entryRevision: PostPurchaseProgressSchema.shape.entryRevision,
   productId: PostPurchaseProgressSchema.shape.members.element.shape.productId,
@@ -7450,23 +7747,23 @@ var OfferDeclineRequestSchema = DecideRequestSchema.extend({
   "Selected merchandise requires a variant"
 );
 var RecordedOfferDeclineSchema = PostPurchaseProgressSchema.shape.members.element.omit({ declineDelivery: true, status: true }).extend({ entry: DecisionEntrySchema.strict(), entryRevision: PostPurchaseProgressSchema.shape.entryRevision }).strict();
-var OfferDeclineResponseSchema = import_zod82.z.object({
-  data: import_zod82.z.object({ decline: RecordedOfferDeclineSchema, progress: PostPurchaseProgressSchema }),
-  successful: import_zod82.z.literal(true)
+var OfferDeclineResponseSchema = import_zod86.z.object({
+  data: import_zod86.z.object({ decline: RecordedOfferDeclineSchema, progress: PostPurchaseProgressSchema }),
+  successful: import_zod86.z.literal(true)
 });
 
 // src/server/preparePostPurchaseDeclineDisplay.ts
-var Selection = import_zod83.z.object({
+var Selection = import_zod87.z.object({
   productId: OfferDeclineRequestSchema.shape.productId,
   variant: OfferDeclineRequestSchema.shape.variant.unwrap()
 });
 var preparePostPurchaseDeclineDisplay = (settings, response, requested) => {
-  const selection3 = Selection.parse(requested);
+  const selection4 = Selection.parse(requested);
   const { members, normalized } = normalizePostPurchaseCollection(settings, response);
-  const found = members.find(({ product }) => product.id === selection3.productId);
+  const found = members.find(({ product }) => product.id === selection4.productId);
   if (!found) return null;
   const catalog = projectPostPurchaseVariantCatalog(found.product, normalized.effective);
-  const variant2 = catalog.variants.find(({ id }) => id === selection3.variant.variantId);
+  const variant2 = catalog.variants.find(({ id }) => id === selection4.variant.variantId);
   return variant2 ? { productTitle: found.product.title, variantId: variant2.id, variantTitle: variant2.title } : null;
 };
 
@@ -7485,41 +7782,46 @@ var preparePostPurchaseGroupDeclineDisplay = (settings, response, requested, exc
 };
 
 // src/server/preparePostPurchaseOfferPresentation.ts
-var import_compat7 = require("es-toolkit/compat");
-var import_zod85 = require("zod");
+var import_compat8 = require("es-toolkit/compat");
+var import_zod89 = require("zod");
 
 // src/schema/postPurchaseOfferPresentation.ts
-var import_zod84 = require("zod");
+var import_zod88 = require("zod");
 var language2 = PostPurchaseSettings.shape.language.shape.global.unwrap().unwrap();
-var PostPurchaseOfferPresentation = import_zod84.z.strictObject({
+var PostPurchaseOfferPresentation = import_zod88.z.strictObject({
   labels: language2.pick({ declineAll: true, declineThisOffer: true }),
   layout: PostPurchaseSettings.shape.offersLayout,
   sections: CABRootSection.nullable(),
   showDeclineAll: PostPurchaseSettings.shape.productOptions.shape.showDeclineAll
 });
 var OfferPresentationRequestSchema = DecideRequestSchema.strict();
-var OfferPresentationResponseSchema = import_zod84.z.object({
-  data: import_zod84.z.strictObject({
+var OfferPresentationResponseSchema = import_zod88.z.object({
+  data: import_zod88.z.strictObject({
     presentation: PostPurchaseOfferPresentation.nullable(),
     progress: PostPurchaseProgressSchema.nullable(),
     serverNow: PostPurchaseTimestampSchema
   }),
-  successful: import_zod84.z.literal(true)
+  successful: import_zod88.z.literal(true)
 });
 
 // src/server/preparePostPurchaseOfferPresentation.ts
 var FrameSettings = PostPurchaseSettings.pick({ language: true, offersLayout: true, productOptions: true }).extend({
-  blocks: import_zod85.z.array(import_zod85.z.unknown()).optional()
+  blocks: import_zod89.z.array(import_zod89.z.unknown()).optional()
 });
 var preparePostPurchaseOfferPresentation = (widgetId, settings, response, report) => {
   const { metadata } = PostPurchaseProductSource.pick({ metadata: true }).parse(deepCamelCase(response));
   const original = FrameSettings.parse(deepCamelCase(settings));
-  const effective = FrameSettings.parse((0, import_compat7.merge)({}, original, metadata.widget));
+  const merged = (0, import_compat8.merge)({}, deepCamelCase(settings), metadata.widget);
+  const effective = FrameSettings.parse((0, import_compat8.merge)({}, original, metadata.widget));
   let sections = null;
   try {
     sections = convertMessagePreview(
       widgetId,
-      { blocks: postPurchaseOfferCopy(effective.blocks, metadata), type: "shopify_post_purchase_extension" },
+      {
+        ...merged,
+        blocks: postPurchaseOfferCopy(effective.blocks, metadata),
+        type: "shopify_post_purchase_extension"
+      },
       report
     );
   } catch (error) {
@@ -7534,7 +7836,7 @@ var preparePostPurchaseOfferPresentation = (widgetId, settings, response, report
 };
 
 // src/server/analytics.ts
-var import_es_toolkit7 = require("es-toolkit");
+var import_es_toolkit8 = require("es-toolkit");
 
 // src/server/analyticsSegments.ts
 var SEGMENT_BUCKETS = {
@@ -7653,7 +7955,7 @@ var postAnalyticsEvents = async (input, ctx) => {
   const events = input.events.map((event) => translateAnalyticsEvent(event, input)).filter((event) => event !== null);
   if (events.length === 0) return { accepted: 0 };
   const { shop } = await fetchUserConfig({ shop: input.shop }, ctx);
-  for (const batch of (0, import_es_toolkit7.chunk)(events, MAX_ANALYTICS_EVENTS)) {
+  for (const batch of (0, import_es_toolkit8.chunk)(events, MAX_ANALYTICS_EVENTS)) {
     await ctx.fetchUpstream(
       "/api/v2/analytics/event/bulk",
       {},
@@ -7669,7 +7971,7 @@ var postAnalyticsEvents = async (input, ctx) => {
 };
 
 // src/server/requestSchemas.ts
-var import_zod86 = require("zod");
+var import_zod90 = require("zod");
 var REQUEST_BOUNDS = {
   /** Cart-level attributes per cart. */
   CART_ATTRIBUTES_MAX: 100,
@@ -7700,42 +8002,42 @@ var REQUEST_BOUNDS = {
   /** Rich ads transaction lines — the engine's ads contract. */
   TRANSACTION_ITEMS_MAX: 50
 };
-var KeyValue = import_zod86.z.object({
-  key: import_zod86.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX),
-  value: import_zod86.z.string().max(REQUEST_BOUNDS.STRING_VALUE_MAX).optional()
+var KeyValue = import_zod90.z.object({
+  key: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX),
+  value: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_VALUE_MAX).optional()
 });
-var CartLineInputSchema = import_zod86.z.object({
-  productId: import_zod86.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
-  properties: import_zod86.z.array(KeyValue).max(REQUEST_BOUNDS.LINE_PROPERTIES_MAX).optional(),
-  quantity: import_zod86.z.number(),
-  subscriptionId: import_zod86.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  variantId: import_zod86.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX)
+var CartLineInputSchema = import_zod90.z.object({
+  productId: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  properties: import_zod90.z.array(KeyValue).max(REQUEST_BOUNDS.LINE_PROPERTIES_MAX).optional(),
+  quantity: import_zod90.z.number(),
+  subscriptionId: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  variantId: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX)
 });
-var CartInputSchema = import_zod86.z.object({
-  attributes: import_zod86.z.array(KeyValue).max(REQUEST_BOUNDS.CART_ATTRIBUTES_MAX).optional(),
+var CartInputSchema = import_zod90.z.object({
+  attributes: import_zod90.z.array(KeyValue).max(REQUEST_BOUNDS.CART_ATTRIBUTES_MAX).optional(),
   /**
    * Presentment-per-shop-currency FX rate (buyer price ÷ shop price, e.g. `1.35` for a USD shop
    * selling in CAD). Money rule thresholds are authored in SHOP currency, so the engine subtotal is
    * divided by this before evaluation. Omit (or send 1) when the cart is already in the shop's currency.
    */
-  currencyRate: import_zod86.z.number().optional(),
+  currencyRate: import_zod90.z.number().optional(),
   /** Applied discount codes; the engine evaluates `discount_code` rules against them (sent as `[{code}]`). */
-  discountCodes: import_zod86.z.array(import_zod86.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX)).max(REQUEST_BOUNDS.DISCOUNT_CODES_MAX).optional(),
+  discountCodes: import_zod90.z.array(import_zod90.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX)).max(REQUEST_BOUNDS.DISCOUNT_CODES_MAX).optional(),
   /** Presentment cents of cart-level discount allocations, subtracted from `subtotal` for the engine. */
-  discountTotal: import_zod86.z.number().optional(),
-  items: import_zod86.z.array(CartLineInputSchema).max(REQUEST_BOUNDS.CART_ITEMS_MAX),
+  discountTotal: import_zod90.z.number().optional(),
+  items: import_zod90.z.array(CartLineInputSchema).max(REQUEST_BOUNDS.CART_ITEMS_MAX),
   /** Presentment subtotal in cents. */
-  subtotal: import_zod86.z.number()
+  subtotal: import_zod90.z.number()
 });
-var UserConfigInputSchema = import_zod86.z.object({ shop: import_zod86.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX) });
-var DataSourceInputSchema = import_zod86.z.object({
+var UserConfigInputSchema = import_zod90.z.object({ shop: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX) });
+var DataSourceInputSchema = import_zod90.z.object({
   cart: CartInputSchema,
   /**
    * Numeric Shopify company-location id when the buyer is a B2B session (`buyerIdentity.purchasingCompany`).
    * Present ⇒ the orchestrator filters results by the location's catalog via admin-api (REB-23713); the
    * client's country-context market check is bypassed for B2B (it false-negatives B2B-catalog products).
    */
-  companyLocationId: import_zod86.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  companyLocationId: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
   /**
    * Buyer's market country (ISO 3166-1 alpha-2) — forwarded to the engine as the `country_code` PARAM
    * when the shop's markets toggle is on (REB-21688; the sink was the `X-Country-Code` header under
@@ -7744,16 +8046,16 @@ var DataSourceInputSchema = import_zod86.z.object({
    * uppercase (the wire value is forwarded verbatim as the param) so a case-sensitive engine lookup
    * can't silently miss a lowercase code — `adsEngine.ts` uppercases for the same reason.
    */
-  country: import_zod86.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).regex(/^[A-Za-z]{2}$/, "must be an ISO 3166-1 alpha-2 country code (e.g. CA)").transform((value) => value.toUpperCase()).optional(),
-  customerId: import_zod86.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  dataSourcePath: import_zod86.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX),
+  country: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).regex(/^[A-Za-z]{2}$/, "must be an ISO 3166-1 alpha-2 country code (e.g. CA)").transform((value) => value.toUpperCase()).optional(),
+  customerId: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  dataSourcePath: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX),
   /**
    * Engine `filter_inputs` override: `'no'` keeps in-cart (input) products in the results/rule
    * outputs — gift validation sends it so a gift's own product can appear in its answer. Omitted = the
    * engine's default filtering.
    */
-  filterInputs: import_zod86.z.enum(["no", "yes"]).optional(),
-  integrations: import_zod86.z.record(import_zod86.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX), import_zod86.z.boolean()).refine((record) => Object.keys(record).length <= REQUEST_BOUNDS.INTEGRATION_KEYS_MAX, {
+  filterInputs: import_zod90.z.enum(["no", "yes"]).optional(),
+  integrations: import_zod90.z.record(import_zod90.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX), import_zod90.z.boolean()).refine((record) => Object.keys(record).length <= REQUEST_BOUNDS.INTEGRATION_KEYS_MAX, {
     message: `Too many integration keys (max ${REQUEST_BOUNDS.INTEGRATION_KEYS_MAX})`
   }).optional(),
   /**
@@ -7766,31 +8068,31 @@ var DataSourceInputSchema = import_zod86.z.object({
    * request header) fails the regex. Callers should send the buyer's resolved locale (e.g. Shopify
    * checkout's `localization.language.isoCode`), not the request header verbatim.
    */
-  language: import_zod86.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).regex(/^[A-Za-z0-9-]+$/, "must be a single BCP-47 tag (e.g. fr-CA), not a q-value list").optional(),
-  limit: import_zod86.z.number().max(REQUEST_BOUNDS.LIMIT_MAX),
-  productType: import_zod86.z.enum(["both", "one-time", "subscription"]).optional(),
-  shop: import_zod86.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
-  visitorId: import_zod86.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
-});
-var GiftInputSchema = import_zod86.z.object({
-  cost: import_zod86.z.number(),
-  discounted: import_zod86.z.boolean(),
+  language: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).regex(/^[A-Za-z0-9-]+$/, "must be a single BCP-47 tag (e.g. fr-CA), not a q-value list").optional(),
+  limit: import_zod90.z.number().max(REQUEST_BOUNDS.LIMIT_MAX),
+  productType: import_zod90.z.enum(["both", "one-time", "subscription"]).optional(),
+  shop: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  visitorId: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
+});
+var GiftInputSchema = import_zod90.z.object({
+  cost: import_zod90.z.number(),
+  discounted: import_zod90.z.boolean(),
   /**
    * Which gift attribution the line carries (REB-24363). Defaults to `gwp` because a client that predates
    * the field only ever sent GWP lines — without the default an older extension's request would 422.
    */
-  kind: import_zod86.z.enum(GIFT_KINDS).default("gwp"),
-  lineId: import_zod86.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
-  productId: import_zod86.z.number(),
+  kind: import_zod90.z.enum(GIFT_KINDS).default("gwp"),
+  lineId: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  productId: import_zod90.z.number(),
   /**
    * The line's unit count (REB-24363) — the selectable-GWP verdict trims surplus units against milestone
    * capacity. The second deliberate default: a client predating the field sent only GWP lines, whose
    * verdict is whole-line, so a missing quantity reads as one unit rather than 422ing the older request.
    */
-  quantity: import_zod86.z.number().int().min(1).default(1),
-  widgetId: import_zod86.z.number()
+  quantity: import_zod90.z.number().int().min(1).default(1),
+  widgetId: import_zod90.z.number()
 });
-var GiftValidationInputSchema = import_zod86.z.object({
+var GiftValidationInputSchema = import_zod90.z.object({
   cart: CartInputSchema,
   /**
    * Buyer's market country — threaded into the per-widget data-source evaluations, which forward it to
@@ -7799,25 +8101,25 @@ var GiftValidationInputSchema = import_zod86.z.object({
    * turns markets off); regex-bound and uppercase-normalized for the same reasons as
    * `DataSourceInputSchema`'s `country`.
    */
-  country: import_zod86.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).regex(/^[A-Za-z]{2}$/, "must be an ISO 3166-1 alpha-2 country code (e.g. CA)").transform((value) => value.toUpperCase()).optional(),
-  customerId: import_zod86.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  gifts: import_zod86.z.array(GiftInputSchema).max(REQUEST_BOUNDS.GIFTS_MAX),
+  country: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).regex(/^[A-Za-z]{2}$/, "must be an ISO 3166-1 alpha-2 country code (e.g. CA)").transform((value) => value.toUpperCase()).optional(),
+  customerId: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  gifts: import_zod90.z.array(GiftInputSchema).max(REQUEST_BOUNDS.GIFTS_MAX),
   /**
    * Buyer's checkout language — threaded into the per-widget data-source evaluations, which normalize
    * and forward it as the engine `locale` param under the same markets-toggle gate (REB-21688). MUST be
    * a single BCP-47 tag, for the same reason as `DataSourceInputSchema`'s `language` above.
    */
-  language: import_zod86.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).regex(/^[A-Za-z0-9-]+$/, "must be a single BCP-47 tag (e.g. fr-CA), not a q-value list").optional(),
-  shop: import_zod86.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
-  visitorId: import_zod86.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
+  language: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).regex(/^[A-Za-z0-9-]+$/, "must be a single BCP-47 tag (e.g. fr-CA), not a q-value list").optional(),
+  shop: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  visitorId: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
 });
-var GiftAdjustmentSchema = import_zod86.z.object({
-  lineId: import_zod86.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
-  quantity: import_zod86.z.number().int().nonnegative()
+var GiftAdjustmentSchema = import_zod90.z.object({
+  lineId: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  quantity: import_zod90.z.number().int().nonnegative()
 });
-var GiftValidationResponseSchema = import_zod86.z.object({
-  adjust: import_zod86.z.array(GiftAdjustmentSchema).max(REQUEST_BOUNDS.GIFTS_MAX).default([]),
-  remove: import_zod86.z.array(import_zod86.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX)).max(REQUEST_BOUNDS.GIFTS_MAX).refine(
+var GiftValidationResponseSchema = import_zod90.z.object({
+  adjust: import_zod90.z.array(GiftAdjustmentSchema).max(REQUEST_BOUNDS.GIFTS_MAX).default([]),
+  remove: import_zod90.z.array(import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX)).max(REQUEST_BOUNDS.GIFTS_MAX).refine(
     (remove) => new Set(remove).size === remove.length,
     "a line id may appear at most once in `remove`"
   )
@@ -7828,47 +8130,47 @@ var GiftValidationResponseSchema = import_zod86.z.object({
   ({ adjust }) => new Set(adjust.map(({ lineId }) => lineId)).size === adjust.length,
   "a line id may appear at most once in `adjust`"
 );
-var MonetizeTransactionItemSchema = import_zod86.z.object({
-  id: import_zod86.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
-  priceCents: import_zod86.z.number(),
-  quantity: import_zod86.z.number(),
-  title: import_zod86.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX),
-  type: import_zod86.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX)
-});
-var MonetizeInputSchema = import_zod86.z.object({
+var MonetizeTransactionItemSchema = import_zod90.z.object({
+  id: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  priceCents: import_zod90.z.number(),
+  quantity: import_zod90.z.number(),
+  title: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX),
+  type: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX)
+});
+var MonetizeInputSchema = import_zod90.z.object({
   cart: CartInputSchema,
   /** Client-minted render-beacon correlation id; forwarded to the ads engine as `client_request_id`. */
-  clientRequestId: import_zod86.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  country: import_zod86.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  currency: import_zod86.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  clientRequestId: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  country: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  currency: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
   /** Ads-targeting identity/geo/locale fields (React parity); folded into the engine query verbatim. */
-  customerEmail: import_zod86.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
-  customerFirstName: import_zod86.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
-  customerId: import_zod86.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  customerLastName: import_zod86.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
-  language: import_zod86.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  customerEmail: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
+  customerFirstName: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
+  customerId: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  customerLastName: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
+  language: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
   /** Buyer-facing order name (e.g. `#1001`) for the server-composed "Order … Confirmed" chrome line. */
-  orderName: import_zod86.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
+  orderName: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
   /** Ads surface label, forwarded verbatim; `customer_account` is measured/floored as its own surface (the account-area order list). */
-  placement: import_zod86.z.enum(["customer_account", "order_status", "thank_you_page"]),
+  placement: import_zod90.z.enum(["customer_account", "order_status", "thank_you_page"]),
   /** Privacy Policy footer href — the Monetize widget's `privacy_policy_url` setting (React parity). */
-  privacyPolicyUrl: import_zod86.z.string().max(REQUEST_BOUNDS.STRING_URL_MAX).optional(),
+  privacyPolicyUrl: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_URL_MAX).optional(),
   /** 30-min rolling session id (React parity); used for the ads `session_id`, else the visitor id. */
-  sessionId: import_zod86.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  shop: import_zod86.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  sessionId: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  shop: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
   /** Editor/QA indicator; OR-ed into the ads-engine `testing` flag so it stays out of billing/reporting. */
-  testing: import_zod86.z.boolean().optional(),
-  timezone: import_zod86.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  testing: import_zod90.z.boolean().optional(),
+  timezone: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
   /** Decorated (numeric) order id → the ads `transaction_id`. */
-  transactionId: import_zod86.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  transactionId: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
   /** Rich per-line ads items; capped at the engine's ads contract. Preferred over `cart.items`. */
-  transactionItems: import_zod86.z.array(MonetizeTransactionItemSchema).max(REQUEST_BOUNDS.TRANSACTION_ITEMS_MAX).optional(),
+  transactionItems: import_zod90.z.array(MonetizeTransactionItemSchema).max(REQUEST_BOUNDS.TRANSACTION_ITEMS_MAX).optional(),
   /** Order total in presentment cents (React prefers total over subtotal); else `cart.subtotal`. */
-  transactionTotal: import_zod86.z.number().optional(),
-  visitorId: import_zod86.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  zipCode: import_zod86.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
+  transactionTotal: import_zod90.z.number().optional(),
+  visitorId: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  zipCode: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
 });
-var WidgetSettingsInputSchema = import_zod86.z.object({
+var WidgetSettingsInputSchema = import_zod90.z.object({
   /**
    * Same domain as `CabShopConfig.cacheKey`, for the same reason: this side WINS the orchestrator's
    * `input.cacheKey ?? config.shop.cacheKey` (and an explicit value skips the config read entirely), so
@@ -7876,9 +8178,9 @@ var WidgetSettingsInputSchema = import_zod86.z.object({
    * and pin the edge copy permanently stale. `.catch(undefined)` because a bogus buster should degrade
    * the read to un-busted, never 400 a widget render.
    */
-  cacheKey: import_zod86.z.number().int().positive().optional().catch(void 0),
-  id: import_zod86.z.number(),
-  key: import_zod86.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  cacheKey: import_zod90.z.number().int().positive().optional().catch(void 0),
+  id: import_zod90.z.number(),
+  key: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
   /**
    * Monetize context for inline hydration: when present AND the widget converts to a Monetize marker,
    * the server fetches/composes the offer cards inside this same request (no second `/cab/monetize`
@@ -7887,34 +8189,34 @@ var WidgetSettingsInputSchema = import_zod86.z.object({
    * `privacyPolicyUrl` comes from the widget settings server-side (more authoritative than a relay).
    */
   monetize: MonetizeInputSchema.omit({ privacyPolicyUrl: true, shop: true }).optional(),
-  shop: import_zod86.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  shop: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
   /** Stable per-buyer id; when present, enables sticky server-side A/B variant selection. */
-  visitorId: import_zod86.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
+  visitorId: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
 });
-var AnalyticsEventInputSchema = import_zod86.z.object({
-  name: import_zod86.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX),
-  properties: import_zod86.z.record(import_zod86.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX), import_zod86.z.unknown()).optional(),
-  sentAt: import_zod86.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
+var AnalyticsEventInputSchema = import_zod90.z.object({
+  name: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX),
+  properties: import_zod90.z.record(import_zod90.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX), import_zod90.z.unknown()).optional(),
+  sentAt: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
 });
-var AnalyticsSegmentsInputSchema = import_zod86.z.object({
-  device: import_zod86.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional().catch(void 0),
-  source: import_zod86.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional().catch(void 0),
-  visitor: import_zod86.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional().catch(void 0)
+var AnalyticsSegmentsInputSchema = import_zod90.z.object({
+  device: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional().catch(void 0),
+  source: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional().catch(void 0),
+  visitor: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional().catch(void 0)
 });
-var AnalyticsInputSchema = import_zod86.z.object({
+var AnalyticsInputSchema = import_zod90.z.object({
   /** Rebuy cart token (the `r_cart_token` cart attribute), when available — primary aggregation key. */
-  cartToken: import_zod86.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  cartToken: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
   /** Shopify checkout token, when available — drives cart/checkout aggregation downstream. */
-  checkoutToken: import_zod86.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  events: import_zod86.z.array(AnalyticsEventInputSchema).max(REQUEST_BOUNDS.EVENTS_MAX),
+  checkoutToken: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  events: import_zod90.z.array(AnalyticsEventInputSchema).max(REQUEST_BOUNDS.EVENTS_MAX),
   /**
    * Request-scoped like the tokens: one visitor's segments apply to every event in the batch. The container
    * degrades too (`null` is a realistic wire artifact of `attributes ? {…} : null`), so the degrade rule is
    * total: nothing about `segments` can cost the envelope.
    */
   segments: AnalyticsSegmentsInputSchema.optional().catch(void 0),
-  shop: import_zod86.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
-  visitorId: import_zod86.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  shop: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  visitorId: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
   /** The widget id (smartBlockId) the events belong to. */
-  widgetId: import_zod86.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
+  widgetId: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
 });