@rebuy/rebuy 3.41.0 → 3.43.0

package/dist/index.mjs

@@ -1530,6 +1530,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"];
@@ -2325,6 +2327,7 @@ var PreparedPostPurchaseProduct = z22.object({
   labels: z22.object({
     declineAll: global.declineAll,
     free: z22.string(),
+    notAvailable: global.notAvailable,
     payNow: z22.string(),
     quantity: z22.string(),
     recurringShipping: global.recurringShipping,
@@ -2427,6 +2430,8 @@ var PostPurchaseProductChangeset = z23.object({
 });
 
 // src/schema/postPurchaseAdmission.ts
+var PurchaseAdmissionModeSchema = z24.enum(["purchase", "upgrade"]);
+var selection = PreparedPostPurchaseProduct.shape.selection;
 var PurchaseExpectedSchema = z24.object({
   buyerConsentToSubscriptions: z24.boolean().optional(),
   changeset: PostPurchaseProductChangeset.extend({
@@ -2434,16 +2439,20 @@ var PurchaseExpectedSchema = z24.object({
   }),
   entry: DecisionEntrySchema,
   member: PostPurchaseMemberIdentity.optional(),
+  mode: PurchaseAdmissionModeSchema.optional(),
   progressRevision: z24.number().int().nonnegative().optional(),
-  selection: PreparedPostPurchaseProduct.shape.selection
+  selection
 }).refine(
   ({ member, progressRevision }) => !member || progressRevision !== void 0,
   "Captured member requires progress"
-).refine(({ buyerConsentToSubscriptions: consent, changeset, selection: selection2 }) => {
+).refine(
+  ({ mode, selection: { sellingPlanId } }) => mode !== "upgrade" || sellingPlanId !== void 0,
+  "An upgrade selects a subscription"
+).refine(({ buyerConsentToSubscriptions: consent, changeset, selection: selection3 }) => {
   const [change, shipping] = changeset.changes;
-  if (selection2.sellingPlanId === void 0)
-    return consent !== true && change?.type === "add_variant" && change.variantId === selection2.variantId && change.quantity === selection2.quantity && (shipping === void 0 || shipping.type === "add_shipping_line");
-  return consent === true && changeset.changes.length === 1 && change.type === "add_subscription" && change.sellingPlanId === selection2.sellingPlanId && change.variantId === selection2.variantId && change.quantity === selection2.quantity;
+  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;
 }, "Selection, change and buyer consent must agree");
 var PurchaseRequestSchema = DecideRequestSchema.extend({
   expected: PurchaseExpectedSchema,
@@ -2452,12 +2461,18 @@ var PurchaseRequestSchema = DecideRequestSchema.extend({
 var PurchaseReceiptSchema = z24.object({
   admittedAt: PostPurchaseTimestampSchema,
   changesetToken: z24.string().min(1),
+  mode: PurchaseAdmissionModeSchema.optional(),
   operationId: z24.uuid(),
+  /** The server-bound one-time line an upgrade refunds; its quantity is the order's, not the selection's. */
+  originalLine: z24.strictObject({ quantity: selection.shape.quantity, variantId: selection.shape.variantId }).optional(),
   requiresSubscriptionConsent: z24.boolean(),
-  selection: PreparedPostPurchaseProduct.shape.selection
+  selection
 }).refine(
-  ({ requiresSubscriptionConsent, selection: selection2 }) => requiresSubscriptionConsent === (selection2.sellingPlanId !== void 0),
+  ({ requiresSubscriptionConsent, selection: selection3 }) => requiresSubscriptionConsent === (selection3.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 = z24.object({ data: PurchaseReceiptSchema, successful: z24.literal(true) });
 
@@ -2516,6 +2531,8 @@ import { z as z29 } from "zod";
 import { z as z28 } from "zod";
 var PostPurchasePlanOption = z28.object({
   adjustment: PostPurchasePlanAdjustment.optional(),
+  /** cab-checkout's `discountPercentage`: the plan's own whole-percent saving on the regular price (`{{subscriptionDiscount}}`). */
+  discountPercentage: z28.number().int().min(0).max(100).optional(),
   id: z28.number().int().positive(),
   intervalFrequency: z28.string().regex(/^[1-9]\d*$/).optional(),
   intervalLabel: z28.string().min(1),
@@ -2635,85 +2652,120 @@ var OfferDeclineResponseSchema = z34.object({
   successful: z34.literal(true)
 });
 
-// src/schema/postPurchaseEligibility.ts
+// src/schema/postPurchaseDisplayPrice.ts
+import { z as z36 } from "zod";
+
+// src/schema/postPurchaseSubscriptionDisplay.ts
 import { z as z35 } from "zod";
-var PostPurchaseSkipReasonSchema = z35.enum(["empty", "no-eligible-subscription"]);
+var Minor2 = z35.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+var PostPurchaseSubscriptionDisplay = z35.object({
+  comparisonMinor: Minor2,
+  currencyCode: z35.string().regex(/^[A-Z]{3}$/),
+  priceMinor: Minor2,
+  savingMinor: Minor2,
+  savingPercent: z35.number().int().min(0).max(100)
+});
+
+// src/schema/postPurchaseDisplayPrice.ts
+var { currencyCode: CurrencyCode, priceMinor: Minor3, savingPercent: Percent } = PostPurchaseSubscriptionDisplay.shape;
+var PostPurchaseDisplayPrice = z36.object({
+  currencyCode: CurrencyCode,
+  savingFormat: z36.enum(["amount", "percent"]),
+  savingMinor: Minor3,
+  savingPercent: Percent,
+  subscriptionUnit: PostPurchaseSubscriptionDisplay.optional(),
+  variantCompareAtPriceMinor: Minor3.nullable(),
+  variantPriceMinor: Minor3
+}).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/postPurchaseEligibility.ts
+import { z as z37 } from "zod";
+var PostPurchaseSkipReasonSchema = z37.enum(["empty", "no-eligible-subscription"]);
 
 // src/schema/postPurchaseExitPolicy.ts
-import { z as z36 } from "zod";
+import { z as z38 } from "zod";
 var EXIT_DELAY_MAX_MS = 60 * 60 * 1e3;
-var ExitPolicySchema = z36.discriminatedUnion("status", [
-  z36.strictObject({ status: z36.literal("unavailable") }),
-  z36.strictObject({
-    delayMs: z36.number().int().nonnegative().max(EXIT_DELAY_MAX_MS),
-    source: z36.enum(["admitted", "selected-flow"]),
-    status: z36.literal("available")
+var ExitPolicySchema = z38.discriminatedUnion("status", [
+  z38.strictObject({ status: z38.literal("unavailable") }),
+  z38.strictObject({
+    delayMs: z38.number().int().nonnegative().max(EXIT_DELAY_MAX_MS),
+    source: z38.enum(["admitted", "selected-flow"]),
+    status: z38.literal("available")
   })
 ]);
 
 // src/schema/postPurchaseFinish.ts
-import { z as z42 } from "zod";
+import { z as z45 } from "zod";
 
 // src/schema/postPurchaseFollowups.ts
-import { z as z40 } from "zod";
+import { z as z43 } from "zod";
 
 // src/schema/postPurchaseHealthProgress.ts
-import { z as z38 } from "zod";
+import { z as z40 } from "zod";
 
 // src/schema/postPurchaseReleaseAuthority.ts
-import { z as z37 } from "zod";
-var PostPurchaseSessionIdSchema = z37.string().regex(/^[a-f0-9]{64}$/);
-var ReleaseOwnerSchema = z37.enum(["rebuy", "shopify"]);
-var ReleaseAuthorityRequestSchema = z37.strictObject({
+import { z as z39 } from "zod";
+var PostPurchaseSessionIdSchema = z39.string().regex(/^[a-f0-9]{64}$/);
+var ReleaseOwnerSchema = z39.enum(["rebuy", "shopify"]);
+var ReleaseAuthorityRequestSchema = z39.strictObject({
   orderId: PostPurchaseOrderIdSchema,
   shop: ShopifyDomainSchema
 });
-var ReadyReleaseAuthoritySchema = z37.object({
+var ReadyReleaseAuthoritySchema = z39.object({
   deadline: PostPurchaseTimestampSchema,
   releaseOwner: ReleaseOwnerSchema,
   sessionId: PostPurchaseSessionIdSchema,
-  status: z37.literal("ready")
+  status: z39.literal("ready")
 });
-var PendingReleaseAuthoritySchema = z37.object({ status: z37.literal("pending") });
-var ReleaseAuthorityResponseSchema = z37.object({
-  data: z37.discriminatedUnion("status", [
-    z37.object({ status: z37.literal("unknown") }),
+var PendingReleaseAuthoritySchema = z39.object({ status: z39.literal("pending") });
+var ReleaseAuthorityResponseSchema = z39.object({
+  data: z39.discriminatedUnion("status", [
+    z39.object({ status: z39.literal("unknown") }),
     PendingReleaseAuthoritySchema,
     ReadyReleaseAuthoritySchema
   ]),
-  successful: z37.literal(true)
+  successful: z39.literal(true)
 });
 
 // src/schema/postPurchaseHealthProgress.ts
-var HealthScheduleSchema = z38.strictObject({
+var HealthScheduleSchema = z40.strictObject({
   checkoutToken: DecideRequestSchema.shape.checkoutToken,
   healthScheduledAt: PostPurchaseTimestampSchema,
   operationId: PurchaseReceiptSchema.shape.operationId.regex(/^[a-f0-9-]{36}$/),
   orderId: PostPurchaseOrderIdSchema,
-  removePartialOrder: z38.boolean(),
+  removePartialOrder: z40.boolean(),
   sessionId: PostPurchaseSessionIdSchema,
   shop: DecideRequestSchema.shape.shop
 });
-var HealthSchedulingResponseSchema = z38.object({
-  data: z38.object({
-    callbackStatus: z38.enum(["pending", "attempted", "returned", "unknown"]),
+var HealthSchedulingResponseSchema = z40.object({
+  data: z40.object({
+    callbackStatus: z40.enum(["pending", "attempted", "returned", "unknown"]),
     facts: HealthScheduleSchema,
-    scheduling: z38.union([
-      z38.strictObject({ recordedAt: PostPurchaseTimestampSchema, status: z38.literal("verified") }),
-      z38.strictObject({ status: z38.enum(["unavailable", "unverified"]) })
+    scheduling: z40.union([
+      z40.strictObject({ recordedAt: PostPurchaseTimestampSchema, status: z40.literal("verified") }),
+      z40.strictObject({ status: z40.enum(["unavailable", "unverified"]) })
     ])
   }),
-  successful: z38.literal(true)
+  successful: z40.literal(true)
 });
 
 // src/schema/postPurchaseObservation.ts
-import { z as z39 } from "zod";
-var PurchaseObservationSchema = z39.union([
-  z39.object({
-    changesetApplicationsRemaining: z39.number().int().nonnegative(),
-    errors: z39.array(
-      z39.object({
-        code: z39.enum([
+import { z as z41 } from "zod";
+var PurchaseObservationSchema = z41.union([
+  z41.object({
+    changesetApplicationsRemaining: z41.number().int().nonnegative(),
+    errors: z41.array(
+      z41.object({
+        code: z41.enum([
           "payment_required",
           "insufficient_inventory",
           "changeset_already_applied",
@@ -2727,83 +2779,126 @@ var PurchaseObservationSchema = z39.union([
           "subscription_limit_error",
           "order_released_error"
         ]),
-        message: z39.string()
+        message: z41.string()
       }).strict()
     ),
-    status: z39.enum(["processed", "partially_processed", "unprocessed"])
+    status: z41.enum(["processed", "partially_processed", "unprocessed"])
   }).strict(),
-  z39.object({ reason: z39.literal("application-error"), status: z39.literal("unknown") }).strict()
+  z41.object({ reason: z41.literal("application-error"), status: z41.literal("unknown") }).strict()
 ]);
-var RecordedPurchaseObservationSchema = z39.object({
+var RecordedPurchaseObservationSchema = z41.object({
   observation: PurchaseObservationSchema,
   recordedAt: PostPurchaseTimestampSchema
 }).strict();
 var PurchaseObservationRequestSchema = DecideRequestSchema.extend({
   observation: PurchaseObservationSchema,
-  operationId: z39.uuid()
+  operationId: z41.uuid()
 }).strict();
-var PurchaseObservationResponseSchema = z39.object({
-  data: RecordedPurchaseObservationSchema.extend({ operationId: z39.uuid() }),
-  successful: z39.literal(true)
+var PurchaseObservationResponseSchema = z41.object({
+  data: RecordedPurchaseObservationSchema.extend({ operationId: z41.uuid() }),
+  successful: z41.literal(true)
 });
 
+// src/schema/postPurchaseUpgrade.ts
+import { z as z42 } from "zod";
+var AttemptSchema2 = z42.strictObject({ attemptedAt: PostPurchaseTimestampSchema, status: z42.literal("attempted") });
+var FinishedSchema = AttemptSchema2.extend({ finishedAt: PostPurchaseTimestampSchema });
+var UpgradeRefundProgressSchema = z42.union([
+  AttemptSchema2,
+  FinishedSchema.extend({ refundId: z42.string().min(1), status: z42.literal("refunded") }),
+  FinishedSchema.extend({ status: z42.enum(["failed", "unknown"]) })
+]);
+var UpgradeCompensationProgressSchema = z42.union([
+  AttemptSchema2,
+  FinishedSchema.extend({ status: z42.enum(["removed", "failed", "unknown"]) })
+]);
+var UpgradeReviewReasonSchema = z42.enum(["refund-unknown", "compensation-failed", "compensation-unknown"]);
+var UpgradeReviewProgressSchema = z42.strictObject({
+  markedAt: PostPurchaseTimestampSchema,
+  marker: AcceptedMetafieldResultSchema.shape.status,
+  reason: UpgradeReviewReasonSchema
+});
+var reviewReason = (refund, compensation) => {
+  if (refund?.status === "unknown") return "refund-unknown";
+  if (compensation?.status === "failed" || compensation?.status === "unknown")
+    return `compensation-${compensation.status}`;
+  return null;
+};
+var UpgradeProgressSchema = z42.strictObject({
+  compensation: UpgradeCompensationProgressSchema.nullable(),
+  operationId: PurchaseReceiptSchema.shape.operationId,
+  refund: UpgradeRefundProgressSchema.nullable(),
+  review: UpgradeReviewProgressSchema.nullable()
+}).refine(
+  ({ compensation, refund }) => compensation === null || refund?.status === "failed",
+  "Compensation follows a known refund failure only"
+).refine(
+  ({ compensation, refund, review }) => (review?.reason ?? null) === reviewReason(refund, compensation),
+  "Review must match the unresolved outcome"
+);
+
 // src/schema/postPurchaseFollowups.ts
-var RequiredHealthSchema = z40.union([
+var RequiredHealthSchema = z43.union([
   HealthSchedulingResponseSchema.shape.data,
-  z40.strictObject({ status: z40.literal("unavailable") })
+  z43.strictObject({ status: z43.literal("unavailable") })
 ]);
-var AcceptedFollowupsResponseSchema = z40.object({
-  data: z40.object({
-    acceptedEvent: z40.union([
+var AcceptedFollowupsResponseSchema = z43.object({
+  data: z43.object({
+    acceptedEvent: z43.union([
       AcceptedEventResponseSchema.shape.data,
-      z40.strictObject({ status: z40.literal("unavailable") })
+      z43.strictObject({ status: z43.literal("unavailable") })
     ]),
     acceptedMetafield: AcceptedMetafieldResultSchema,
     health: RequiredHealthSchema,
-    purchase: PurchaseObservationResponseSchema.shape.data
+    purchase: PurchaseObservationResponseSchema.shape.data,
+    /** Present only for an upgrade admission, and always for the same operation as `purchase`. */
+    upgrade: UpgradeProgressSchema.optional()
+  }).refine(({ purchase, upgrade }) => !upgrade || upgrade.operationId === purchase.operationId, {
+    message: "Upgrade progress belongs to its operation",
+    path: ["upgrade", "operationId"]
   }),
-  successful: z40.literal(true)
+  successful: z43.literal(true)
 });
 
 // src/schema/postPurchaseSessionClose.ts
-import { z as z41 } from "zod";
-var SessionClosureSchema = z41.object({ closedAt: PostPurchaseTimestampSchema, status: z41.literal("closed") });
+import { z as z44 } from "zod";
+var SessionClosureSchema = z44.object({ closedAt: PostPurchaseTimestampSchema, status: z44.literal("closed") });
 var SessionCloseRequestSchema = DecideRequestSchema.strict();
-var SessionCloseResponseSchema = z41.object({ data: SessionClosureSchema, successful: z41.literal(true) });
+var SessionCloseResponseSchema = z44.object({ data: SessionClosureSchema, successful: z44.literal(true) });
 
 // src/schema/postPurchaseFinish.ts
-var FinishedPurchaseSchema = z42.union([
-  z42.strictObject({ status: z42.literal("none") }),
-  z42.strictObject({
+var FinishedPurchaseSchema = z45.union([
+  z45.strictObject({ status: z45.literal("none") }),
+  z45.strictObject({
     operationId: PurchaseReceiptSchema.shape.operationId,
-    status: z42.union([
-      z42.literal("pending"),
+    status: z45.union([
+      z45.literal("pending"),
       ...PurchaseObservationSchema.options.map((option) => option.shape.status)
     ])
   })
 ]);
 var SessionFinishRequestSchema = DecideRequestSchema.strict();
-var SessionFinishResponseSchema = z42.object({
+var SessionFinishResponseSchema = z45.object({
   data: SessionClosureSchema.extend({
     classification: ClassificationProgressSchema,
     exitPolicy: ExitPolicySchema,
     health: RequiredHealthSchema.nullable(),
     purchase: FinishedPurchaseSchema
   }),
-  successful: z42.literal(true)
+  successful: z45.literal(true)
 });
 
 // src/schema/postPurchaseQuantity.ts
-import { z as z65 } from "zod";
+import { z as z69 } from "zod";
 
 // src/schema/postPurchaseProductCollectionView.ts
-import { z as z64 } from "zod";
+import { z as z68 } from "zod";
 
 // src/schema/postPurchaseProductView.ts
-import { z as z63 } from "zod";
+import { z as z67 } from "zod";
 
 // src/schema/postPurchaseGroupCatalog.ts
-import { z as z43 } from "zod";
+import { z as z46 } from "zod";
 var productId = PreparedPostPurchaseProduct.shape.selection.shape.productId;
 var source = PostPurchaseProductSource.shape.data.element;
 var PostPurchaseGroupDescription = source.pick({ description: true, id: true, image: true, images: true, title: true }).extend({
@@ -2811,17 +2906,17 @@ var PostPurchaseGroupDescription = source.pick({ description: true, id: true, im
   image: source.shape.image.default(null),
   options: PostPurchaseVariantCatalog.shape.options.default([])
 });
-var PostPurchaseGroupCatalog = z43.object({
+var PostPurchaseGroupCatalog = z46.object({
   memberProductId: productId,
-  options: z43.array(z43.object({ productId, title: z43.string(), variantCatalog: PostPurchaseVariantCatalog }))
+  options: z46.array(z46.object({ productId, title: z46.string(), variantCatalog: PostPurchaseVariantCatalog }))
 });
-var PostPurchaseGroupSelection = z43.object({
+var PostPurchaseGroupSelection = z46.object({
   memberProductId: productId,
   productId
 });
 
 // src/schema/widgets/checkout-and-beyond/root.ts
-import { z as z62 } from "zod";
+import { z as z66 } from "zod";
 
 // src/schema/widgets/checkout-and-beyond/constants.ts
 import { uniqBy } from "es-toolkit";
@@ -2876,18 +2971,18 @@ var targetAreas = {
 
 // src/schema/widgets/checkout-and-beyond/layout.ts
 import { v7 as uuidv713 } from "uuid";
-import { z as z61 } from "zod";
+import { z as z65 } from "zod";
 
 // src/schema/widgets/checkout-and-beyond/shared.ts
-import { z as z60 } from "zod";
+import { z as z64 } from "zod";
 
 // src/schema/widgets/checkout-and-beyond/banner.ts
-import { z as z44 } from "zod";
-var CABBannerSection = z44.lazy(
+import { z as z47 } from "zod";
+var CABBannerSection = z47.lazy(
   () => CABLayoutSection.omit({ sectionType: true }).extend({
-    buttonField: z44.enum(buttonFields).optional(),
-    color: z44.enum(bannerColors).default("info"),
-    dismissible: z44.boolean().default(true),
+    buttonField: z47.enum(buttonFields).optional(),
+    color: z47.enum(bannerColors).default("info"),
+    dismissible: z47.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.
@@ -2903,18 +2998,18 @@ var CABBannerSection = z44.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: z44.record(z44.string(), z44.string().refine(checkForHTML, NO_HTML)).optional(),
-    sectionType: z44.literal(SectionType.banner).default(SectionType.banner)
+    heading: z47.record(z47.string(), z47.string().refine(checkForHTML, NO_HTML)).optional(),
+    sectionType: z47.literal(SectionType.banner).default(SectionType.banner)
   })
 );
 
 // src/schema/widgets/checkout-and-beyond/button.ts
 import { v7 as uuidv73 } from "uuid";
-import { z as z46 } from "zod";
+import { z as z50 } from "zod";
 
 // src/schema/widgets/checkout-and-beyond/image.ts
 import { v7 as uuidv72 } from "uuid";
-import { z as z45 } from "zod";
+import { z as z49 } from "zod";
 
 // src/schema/widgets/checkout-and-beyond/icons.ts
 var iconNames = [
@@ -3000,18 +3095,25 @@ 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
+import { z as z48 } from "zod";
+var CABImageThumbnails = z48.object({
+  limit: z48.number().int().min(1).default(8),
+  perLine: z48.number().int().min(1).max(8).default(4)
+});
+
 // src/schema/widgets/checkout-and-beyond/image.ts
-var CABImageSectionFields = z45.object({
+var CABImageSectionFields = z49.object({
   ...CABVariableFields,
-  altText: z45.string().refine(checkForHTML, NO_HTML).default(""),
+  altText: z49.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: z45.number().positive().nullable().default(null),
-  border: z45.lazy(() => CABBorder),
-  buttonField: z45.enum(buttonFields).optional(),
+  aspectRatio: z49.number().positive().nullable().default(null),
+  border: z49.lazy(() => CABBorder),
+  buttonField: z49.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
@@ -3030,29 +3132,30 @@ var CABImageSectionFields = z45.object({
    * behavior degraded gracefully and told us about it. The client-assembled half of the invariant was never
    * the risky half.
    */
-  category: z45.enum(["gallery", "icon", "icons", "payment-methods", "secure-checkout"]).nullable().default(null),
+  category: z49.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: z45.enum(iconSizes).nullable().default(null),
+  iconSize: z49.enum(iconSizes).nullable().default(null),
   /** `icon`-mode only: the `s-icon` `tone`; `null` ⇒ the component default (`auto`). Ignored by image treatments. */
-  iconTone: z45.enum(iconTones).nullable().default(null),
-  name: z45.string().optional(),
-  naturalHeight: z45.number().default(0),
-  naturalWidth: z45.number().default(0),
+  iconTone: z49.enum(iconTones).nullable().default(null),
+  name: z49.string().optional(),
+  naturalHeight: z49.number().default(0),
+  naturalWidth: z49.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: z45.enum(objectFits).default(ObjectFit.contain),
-  sectionId: z45.uuid().default(() => uuidv72()),
-  sectionType: z45.literal(SectionType.image).default(SectionType.image),
+  objectFit: z49.enum(objectFits).default(ObjectFit.contain),
+  sectionId: z49.uuid().default(() => uuidv72()),
+  sectionType: z49.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: z45.union([z45.url(), z45.literal(""), z45.string().regex(DYNAMIC_TOKEN_REGEX), z45.enum(iconNames)]).default(""),
-  width: z45.number().default(100)
+  source: z49.union([z49.url(), z49.literal(""), z49.string().regex(DYNAMIC_TOKEN_REGEX), z49.enum(iconNames)]).default(""),
+  thumbnails: CABImageThumbnails.optional(),
+  width: z49.number().default(100)
 });
 var iconNameSet = new Set(iconNames);
 var isIconName = (source2) => iconNameSet.has(source2);
@@ -3072,35 +3175,35 @@ var CABImageSection = CABImageSectionFields.superRefine(({ category, source: sou
 });
 
 // src/schema/widgets/checkout-and-beyond/button.ts
-var CABButtonContent = z46.lazy(
-  () => z46.discriminatedUnion("sectionType", [CABImageSection, CABLayoutSection, CABTextSection])
+var CABButtonContent = z50.lazy(
+  () => z50.discriminatedUnion("sectionType", [CABImageSection, CABLayoutSection, CABTextSection])
 );
-var CABButtonSection = z46.object({
+var CABButtonSection = z50.object({
   ...CABVariableFields,
-  action: z46.union([z46.literal(""), z46.enum(buttonActions)]).default(""),
-  buttonStyle: z46.enum(buttonStyles).default(ButtonStyle.primary),
-  custom: z46.object({
-    color: z46.string().regex(HEX_COLOR_REGEX).default("#005bd3"),
-    height: z46.number().default(52),
-    width: z46.number().default(300)
+  action: z50.union([z50.literal(""), z50.enum(buttonActions)]).default(""),
+  buttonStyle: z50.enum(buttonStyles).default(ButtonStyle.primary),
+  custom: z50.object({
+    color: z50.string().regex(HEX_COLOR_REGEX).default("#005bd3"),
+    height: z50.number().default(52),
+    width: z50.number().default(300)
   }).default({
     color: "#005bd3",
     height: 52,
     width: 300
   }),
-  disableDowngrade: z46.boolean().default(false),
-  name: z46.string().optional(),
-  optionId: z46.number().optional(),
-  popover: z46.object({
-    alignment: z46.enum(textAlignments).default(TextAlignment.center),
-    position: z46.enum(popoverPositions).default(PopoverPosition.blockStart)
+  disableDowngrade: z50.boolean().default(false),
+  name: z50.string().optional(),
+  optionId: z50.number().optional(),
+  popover: z50.object({
+    alignment: z50.enum(textAlignments).default(TextAlignment.center),
+    position: z50.enum(popoverPositions).default(PopoverPosition.blockStart)
   }).optional().default(() => ({
     alignment: TextAlignment.center,
     position: PopoverPosition.blockStart
   })),
-  sectionId: z46.uuid().default(() => uuidv73()),
-  sections: z46.union([z46.array(CABButtonContent), z46.strictObject({}).transform(() => [])]).default(() => []),
-  sectionType: z46.literal(SectionType.button).default(SectionType.button),
+  sectionId: z50.uuid().default(() => uuidv73()),
+  sections: z50.union([z50.array(CABButtonContent), z50.strictObject({}).transform(() => [])]).default(() => []),
+  sectionType: z50.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
@@ -3115,96 +3218,96 @@ var CABButtonSection = z46.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: z46.object({ tierId: z46.string().min(1) }).optional(),
+  tier: z50.object({ tierId: z50.string().min(1) }).optional(),
   /** Fire-and-forget pixel POSTed when the button is clicked (e.g. a Monetize decline). */
-  trackingUrl: z46.string().optional(),
+  trackingUrl: z50.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: z46.array(CABVariableEffect).optional()
+  variableEffects: z50.array(CABVariableEffect).optional()
 });
 
 // src/schema/widgets/checkout-and-beyond/carousel.ts
-import { z as z51 } from "zod";
+import { z as z55 } from "zod";
 
 // src/schema/widgets/checkout-and-beyond/offers.ts
-import { z as z50 } from "zod";
+import { z as z54 } from "zod";
 
 // src/schema/widgets/checkout-and-beyond/dataSource.ts
 import { v7 as uuidv74 } from "uuid";
-import { z as z47 } from "zod";
-var CABDiscount = z47.object({
-  amount: z47.union([z47.number(), z47.string()]).catch(0),
-  discountedBy: z47.string().optional(),
-  discountedFrom: z47.enum(discountSources).optional().catch(void 0),
-  type: z47.enum(discountTypes).catch("none")
-});
-var CABIntegrations = z47.object({
-  judgeme: z47.boolean().default(false),
-  junip: z47.boolean().default(false),
-  klaviyo: z47.boolean().default(false),
-  loox: z47.boolean().default(false),
-  okendo: z47.boolean().default(false),
-  opinew: z47.boolean().default(false),
-  reviewsio: z47.boolean().default(false),
-  stamped: z47.boolean().default(false),
-  yotpo: z47.boolean().default(false)
-});
-var CABVariantLabels = z47.object({
-  variantOption: z47.string().optional().catch(void 0),
-  variantOptions: z47.string().optional().catch(void 0)
-});
-var CABDataSourceSection = z47.object({
-  dataSourceId: z47.number().nullable().default(null),
-  dataSourcePath: z47.string().default(DEFAULT_ENDPOINTS[0].value),
+import { z as z51 } from "zod";
+var CABDiscount = z51.object({
+  amount: z51.union([z51.number(), z51.string()]).catch(0),
+  discountedBy: z51.string().optional(),
+  discountedFrom: z51.enum(discountSources).optional().catch(void 0),
+  type: z51.enum(discountTypes).catch("none")
+});
+var CABIntegrations = z51.object({
+  judgeme: z51.boolean().default(false),
+  junip: z51.boolean().default(false),
+  klaviyo: z51.boolean().default(false),
+  loox: z51.boolean().default(false),
+  okendo: z51.boolean().default(false),
+  opinew: z51.boolean().default(false),
+  reviewsio: z51.boolean().default(false),
+  stamped: z51.boolean().default(false),
+  yotpo: z51.boolean().default(false)
+});
+var CABVariantLabels = z51.object({
+  variantOption: z51.string().optional().catch(void 0),
+  variantOptions: z51.string().optional().catch(void 0)
+});
+var CABDataSourceSection = z51.object({
+  dataSourceId: z51.number().nullable().default(null),
+  dataSourcePath: z51.string().default(DEFAULT_ENDPOINTS[0].value),
   discount: CABDiscount.optional(),
   integrations: CABIntegrations.optional(),
-  limit: z47.number().default(1),
-  matchVariant: z47.boolean().default(false),
-  matchVariantOutOfStock: z47.boolean().default(false),
-  name: z47.string().default(DEFAULT_ENDPOINTS[0].label),
-  productType: z47.enum(productTypes).optional(),
-  sectionId: z47.uuid().default(() => uuidv74()),
-  sectionType: z47.literal(SectionType.dataSource).default(SectionType.dataSource),
+  limit: z51.number().default(1),
+  matchVariant: z51.boolean().default(false),
+  matchVariantOutOfStock: z51.boolean().default(false),
+  name: z51.string().default(DEFAULT_ENDPOINTS[0].label),
+  productType: z51.enum(productTypes).optional(),
+  sectionId: z51.uuid().default(() => uuidv74()),
+  sectionType: z51.literal(SectionType.dataSource).default(SectionType.dataSource),
   /** Default subscribe-vs-one-time for `productType: both` (legacy `subscription_is_default`). */
-  subscriptionIsDefault: z47.boolean().default(false),
-  treatAsGwp: z47.boolean().default(false),
+  subscriptionIsDefault: z51.boolean().default(false),
+  treatAsGwp: z51.boolean().default(false),
   variantLabels: CABVariantLabels.optional().catch(void 0)
 });
 
 // src/schema/widgets/checkout-and-beyond/products.ts
 import { v7 as uuidv76 } from "uuid";
-import { z as z49 } from "zod";
+import { z as z53 } from "zod";
 
 // src/schema/widgets/checkout-and-beyond/product.ts
 import { v7 as uuidv75 } from "uuid";
-import { z as z48 } from "zod";
-var CABVariantContent = z48.lazy(
-  () => z48.discriminatedUnion("sectionType", [CABButtonSection, CABTextSection])
+import { z as z52 } from "zod";
+var CABVariantContent = z52.lazy(
+  () => z52.discriminatedUnion("sectionType", [CABButtonSection, CABTextSection])
 );
-var CABProductSection = z48.object({
+var CABProductSection = z52.object({
   ...CABVariableFields,
-  name: z48.string().optional(),
-  productId: z48.number().nullable().default(null),
-  sectionId: z48.uuid().default(() => uuidv75()),
-  sections: z48.union([z48.array(CABVariantContent), z48.strictObject({}).transform(() => [])]).default(() => []),
-  sectionType: z48.literal(SectionType.product).default(SectionType.product),
-  selectors: z48.record(z48.string(), z48.enum(variantSelectors).default(VariantSelector.menu)).default(() => ({})),
-  variantMode: z48.enum(variantModes).default(VariantMode.multiple)
+  name: z52.string().optional(),
+  productId: z52.number().nullable().default(null),
+  sectionId: z52.uuid().default(() => uuidv75()),
+  sections: z52.union([z52.array(CABVariantContent), z52.strictObject({}).transform(() => [])]).default(() => []),
+  sectionType: z52.literal(SectionType.product).default(SectionType.product),
+  selectors: z52.record(z52.string(), z52.enum(variantSelectors).default(VariantSelector.menu)).default(() => ({})),
+  variantMode: z52.enum(variantModes).default(VariantMode.multiple)
 });
 
 // src/schema/widgets/checkout-and-beyond/products.ts
-var CABProductsSection = z49.object({
+var CABProductsSection = z53.object({
   ...CABVariableFields,
-  name: z49.string().optional(),
-  sectionId: z49.uuid().default(() => uuidv76()),
-  sections: z49.union([z49.array(z49.lazy(() => CABProductSection)), z49.strictObject({}).transform(() => [])]).default(() => []),
-  sectionType: z49.literal(SectionType.products).default(SectionType.products)
+  name: z53.string().optional(),
+  sectionId: z53.uuid().default(() => uuidv76()),
+  sections: z53.union([z53.array(z53.lazy(() => CABProductSection)), z53.strictObject({}).transform(() => [])]).default(() => []),
+  sectionType: z53.literal(SectionType.products).default(SectionType.products)
 });
 
 // src/schema/widgets/checkout-and-beyond/offers.ts
-var CABOffersSection = z50.lazy(
+var CABOffersSection = z54.lazy(
   () => CABLayoutSection.omit({ sections: true, sectionType: true }).extend({
     /**
      * A rule between consecutive cards in the vertical list — legacy checkout-offers' `<Divider />`,
@@ -3212,8 +3315,8 @@ var CABOffersSection = z50.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: z50.boolean().optional(),
-    sections: z50.union([z50.array(z50.lazy(() => CABSection)), z50.strictObject({}).transform(() => [])]).default(() => [
+    divider: z54.boolean().optional(),
+    sections: z54.union([z54.array(z54.lazy(() => CABSection)), z54.strictObject({}).transform(() => [])]).default(() => [
       CABBannerSection.parse({
         buttonField: "undoAddToOrder",
         color: "success",
@@ -3227,77 +3330,77 @@ var CABOffersSection = z50.lazy(
       CABDataSourceSection.parse({}),
       CABProductsSection.parse({})
     ]),
-    sectionType: z50.literal(SectionType.offers).default(SectionType.offers)
+    sectionType: z54.literal(SectionType.offers).default(SectionType.offers)
   })
 );
 
 // src/schema/widgets/checkout-and-beyond/carousel.ts
-var CABCarouselSection = z51.lazy(
+var CABCarouselSection = z55.lazy(
   () => CABLayoutSection.omit({ sections: true, sectionType: true }).extend({
-    autoAdvanceInterval: z51.number().default(0),
-    itemsAtOnce: z51.number().min(1).default(1),
+    autoAdvanceInterval: z55.number().default(0),
+    itemsAtOnce: z55.number().min(1).default(1),
     /** Card arrangement for the offers child (`horizontal` = side-by-side) — NOT the carousel's own `direction`. */
-    offersDirection: z51.enum(offersDirections).default("vertical"),
-    sections: z51.union([z51.array(z51.lazy(() => CABSection)), z51.strictObject({}).transform(() => [])]).default(() => [CABOffersSection.parse({})]),
-    sectionType: z51.literal(SectionType.carousel).default(SectionType.carousel)
+    offersDirection: z55.enum(offersDirections).default("vertical"),
+    sections: z55.union([z55.array(z55.lazy(() => CABSection)), z55.strictObject({}).transform(() => [])]).default(() => [CABOffersSection.parse({})]),
+    sectionType: z55.literal(SectionType.carousel).default(SectionType.carousel)
   })
 );
 
 // src/schema/widgets/checkout-and-beyond/cartLine.ts
-import { z as z52 } from "zod";
-var CABCartLineSection = z52.lazy(
+import { z as z56 } from "zod";
+var CABCartLineSection = z56.lazy(
   () => CABLayoutSection.omit({ sections: true, sectionType: true }).extend({
-    sections: z52.union([z52.array(z52.lazy(() => CABSection)), z52.strictObject({}).transform(() => [])]).default(() => [CABButtonSection.parse({ action: ButtonAction.switchToSubscription })]),
-    sectionType: z52.literal(SectionType.cartLine).default(SectionType.cartLine)
+    sections: z56.union([z56.array(z56.lazy(() => CABSection)), z56.strictObject({}).transform(() => [])]).default(() => [CABButtonSection.parse({ action: ButtonAction.switchToSubscription })]),
+    sectionType: z56.literal(SectionType.cartLine).default(SectionType.cartLine)
   })
 );
 
 // src/schema/widgets/checkout-and-beyond/discount.ts
 import { v7 as uuidv77 } from "uuid";
-import { z as z53 } from "zod";
-var CABDiscountSection = z53.object({
+import { z as z57 } from "zod";
+var CABDiscountSection = z57.object({
   ...CABVariableFields,
-  amount: z53.union([z53.number(), z53.string()]).catch(0),
-  discountedBy: z53.string().optional(),
-  discountedFrom: z53.enum(discountSources).optional().catch(void 0),
-  message: z53.string().optional(),
-  name: z53.string().optional(),
-  quantity: z53.number().default(1),
-  sectionId: z53.uuid().default(() => uuidv77()),
-  sectionType: z53.literal(SectionType.discount).default(SectionType.discount),
-  type: z53.enum(discountTypes).catch("none")
+  amount: z57.union([z57.number(), z57.string()]).catch(0),
+  discountedBy: z57.string().optional(),
+  discountedFrom: z57.enum(discountSources).optional().catch(void 0),
+  message: z57.string().optional(),
+  name: z57.string().optional(),
+  quantity: z57.number().default(1),
+  sectionId: z57.uuid().default(() => uuidv77()),
+  sectionType: z57.literal(SectionType.discount).default(SectionType.discount),
+  type: z57.enum(discountTypes).catch("none")
 });
 
 // src/schema/widgets/checkout-and-beyond/monetize.ts
 import { v7 as uuidv78 } from "uuid";
-import { z as z54 } from "zod";
-var CABMonetizeAds = z54.object({
-  requestId: z54.string().optional(),
+import { z as z58 } from "zod";
+var CABMonetizeAds = z58.object({
+  requestId: z58.string().optional(),
   /** Defaulted here, never in the beacon: absence of information is `ads` itself being absent. */
-  testing: z54.boolean().default(false)
+  testing: z58.boolean().default(false)
 });
-var CABMonetizeSection = z54.object({
+var CABMonetizeSection = z58.object({
   ...CABVariableFields,
   ads: CABMonetizeAds.optional(),
-  name: z54.string().optional(),
+  name: z58.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: z54.array(z54.lazy(() => CABSection)).optional(),
+  offers: z58.array(z58.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: z54.string().optional(),
-  sectionId: z54.uuid().default(() => uuidv78()),
-  sectionType: z54.literal(SectionType.monetize).default(SectionType.monetize),
+  privacyPolicyUrl: z58.string().optional(),
+  sectionId: z58.uuid().default(() => uuidv78()),
+  sectionType: z58.literal(SectionType.monetize).default(SectionType.monetize),
   /** Ads-taxonomy sub-vertical id (the widget's `sub_vertical` setting); paired with `vertical`. */
-  subVertical: z54.string().optional(),
+  subVertical: z58.string().optional(),
   /** Ads-taxonomy vertical id (the widget's `vertical` setting) — with `subVertical`, the admin Monetize editor's two configurables. */
-  vertical: z54.string().optional()
+  vertical: z58.string().optional()
 });
 
 // src/schema/widgets/checkout-and-beyond/progressBar.ts
-import { z as z55 } from "zod";
+import { z as z59 } from "zod";
 
 // src/schema/widgets/checkout-and-beyond/giftLabels.ts
 var GIFT_LABELS = {
@@ -3416,34 +3519,34 @@ var GIFT_LABELS = {
 };
 
 // src/schema/widgets/checkout-and-beyond/progressBar.ts
-var CABProgressTierExclusion = z55.object({
-  collectionIds: z55.array(z55.number().int().positive()).default(() => []),
-  productIds: z55.array(z55.number().int().positive()).default(() => []),
-  tags: z55.array(z55.string().min(1)).default(() => []),
-  type: z55.enum(progressTierExclusionTypes)
+var CABProgressTierExclusion = z59.object({
+  collectionIds: z59.array(z59.number().int().positive()).default(() => []),
+  productIds: z59.array(z59.number().int().positive()).default(() => []),
+  tags: z59.array(z59.string().min(1)).default(() => []),
+  type: z59.enum(progressTierExclusionTypes)
 });
-var CABProgressTier = z55.object({
+var CABProgressTier = z59.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: z55.object({ amount: z55.number().nonnegative(), type: z55.enum(["fixedAmount", "percentage"]) }).optional(),
+  discount: z59.object({ amount: z59.number().nonnegative(), type: z59.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: z55.array(CABProgressTierExclusion).default(() => []),
+  exclusions: z59.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: z55.boolean().default(false),
+  filterOosVariants: z59.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
@@ -3451,10 +3554,10 @@ var CABProgressTier = z55.object({
    * tiers and on tiers with no configured product. Cart add/remove is a later stage; carried here so the
    * tree is complete.
    */
-  gift: z55.object({
-    productId: z55.number().int().positive(),
-    title: z55.string().optional(),
-    variantIds: z55.array(z55.number().int().positive()).default(() => [])
+  gift: z59.object({
+    productId: z59.number().int().positive(),
+    title: z59.string().optional(),
+    variantIds: z59.array(z59.number().int().positive()).default(() => [])
   }).optional(),
   /**
    * The step-row icon's square size in PIXELS (onsite `product_tier_element_size`, an admin px string the
@@ -3474,7 +3577,7 @@ var CABProgressTier = z55.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: z55.number().int().min(1).max(64).default(18),
+  iconSizePx: z59.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
@@ -3484,35 +3587,35 @@ var CABProgressTier = z55.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: z55.record(z55.string(), z55.string()).optional(),
+  label: z59.record(z59.string(), z59.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: z55.boolean().default(false),
+  productTierImage: z59.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: z55.number().int().nonnegative(),
+  threshold: z59.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: z55.record(z55.string(), z55.number().int().nonnegative()).default(() => ({})),
+  thresholds: z59.record(z59.string(), z59.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: z55.string().optional(),
-  tierType: z55.enum(progressTierTypes).default(ProgressTierType.shipping),
+  tierId: z59.string().optional(),
+  tierType: z59.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
@@ -3523,9 +3626,9 @@ var CABProgressTier = z55.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: z55.enum(progressTierUnits).default(ProgressTierUnit.currency)
+  unit: z59.enum(progressTierUnits).default(ProgressTierUnit.currency)
 });
-var CABProgressBarSection = z55.lazy(
+var CABProgressBarSection = z59.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
@@ -3534,35 +3637,35 @@ var CABProgressBarSection = z55.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: z55.string().optional(),
+    barId: z59.string().optional(),
     /** Empty = shown everywhere; otherwise uppercase ISO country codes. */
-    countryCodes: z55.array(z55.string().transform((code) => code.trim().toUpperCase())).default(() => []),
+    countryCodes: z59.array(z59.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: z55.array(z55.string().transform((code) => code.trim().toUpperCase())).default(() => []),
+    excludeCountryCodes: z59.array(z59.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: z55.boolean().default(false),
+    excludeDiscountInSubtotal: z59.boolean().default(false),
     /** Variant ids the client subtracts from the adjusted subtotal (React `bar.excluded_products`). */
-    excludedVariantIds: z55.array(z55.number().int().positive()).default(() => []),
+    excludedVariantIds: z59.array(z59.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: z55.boolean().default(false),
+    freeShippingOnSubscription: z59.boolean().default(false),
     /** Localized heading over the gift controls (onsite `gift_area_title`, default 'FREE GIFTS'). */
-    giftAreaTitle: z55.record(z55.string(), z55.string()).default(() => ({ en: "FREE GIFTS" })),
+    giftAreaTitle: z59.record(z59.string(), z59.string()).default(() => ({ en: "FREE GIFTS" })),
     /** Localized gift-control labels (add/remove/heading); a tier's gift `title` beats `yourGift`. */
-    giftLabels: z55.object({
-      addGift: z55.record(z55.string(), z55.string()).default(() => ({ ...GIFT_LABELS.addGift })),
-      remove: z55.record(z55.string(), z55.string()).default(() => ({ ...GIFT_LABELS.remove })),
-      selectOptions: z55.record(z55.string(), z55.string()).default(() => ({ ...GIFT_LABELS.selectOptions })),
-      yourGift: z55.record(z55.string(), z55.string()).default(() => ({ ...GIFT_LABELS.yourGift }))
+    giftLabels: z59.object({
+      addGift: z59.record(z59.string(), z59.string()).default(() => ({ ...GIFT_LABELS.addGift })),
+      remove: z59.record(z59.string(), z59.string()).default(() => ({ ...GIFT_LABELS.remove })),
+      selectOptions: z59.record(z59.string(), z59.string()).default(() => ({ ...GIFT_LABELS.selectOptions })),
+      yourGift: z59.record(z59.string(), z59.string()).default(() => ({ ...GIFT_LABELS.yourGift }))
     }).default(() => ({
       addGift: { ...GIFT_LABELS.addGift },
       remove: { ...GIFT_LABELS.remove },
@@ -3570,38 +3673,38 @@ var CABProgressBarSection = z55.lazy(
       yourGift: { ...GIFT_LABELS.yourGift }
     })),
     /** The bar's a11y label; the merchant names it in the editor, else this default (React parity). */
-    name: z55.string().default("Order progress"),
+    name: z59.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: z55.string().optional(),
-    sectionType: z55.literal(SectionType.progressBar).default(SectionType.progressBar),
+    progressColor: z59.string().optional(),
+    sectionType: z59.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: z55.union([z55.array(CABProgressTier), z55.strictObject({}).transform(() => [])]).default(() => [])
+    tiers: z59.union([z59.array(CABProgressTier), z59.strictObject({}).transform(() => [])]).default(() => [])
   })
 );
 
 // src/schema/widgets/checkout-and-beyond/quantity.ts
 import { v7 as uuidv79 } from "uuid";
-import { z as z56 } from "zod";
-var CABQuantitySection = z56.object({
+import { z as z60 } from "zod";
+var CABQuantitySection = z60.object({
   ...CABVariableFields,
-  errorMessages: z56.record(
-    z56.string(),
-    z56.object({
+  errorMessages: z60.record(
+    z60.string(),
+    z60.object({
       /** `{{step}}` is interpolated at render — the off-increment message React never gave a merchant key. */
-      increment: z56.string().optional(),
-      max: z56.string().optional(),
-      min: z56.string().optional(),
-      neg: z56.string().optional()
+      increment: z60.string().optional(),
+      max: z60.string().optional(),
+      min: z60.string().optional(),
+      neg: z60.string().optional()
     })
   ).default({
     en: {
@@ -3611,18 +3714,18 @@ var CABQuantitySection = z56.object({
       neg: "Quantity cannot be negative"
     }
   }),
-  inputType: z56.enum(quantityInputs).default(QuantityInput.select),
-  max: z56.number().min(1).max(100).default(10),
-  min: z56.number().min(1).default(1),
+  inputType: z60.enum(quantityInputs).default(QuantityInput.select),
+  max: z60.number().min(1).max(100).default(10),
+  min: z60.number().min(1).default(1),
   /** The a11y label for the quantity control; the merchant names it in the editor, else this default. */
-  name: z56.string().default("Quantity"),
-  sectionId: z56.uuid().default(() => uuidv79()),
-  sectionType: z56.literal(SectionType.quantity).default(SectionType.quantity)
+  name: z60.string().default("Quantity"),
+  sectionId: z60.uuid().default(() => uuidv79()),
+  sectionType: z60.literal(SectionType.quantity).default(SectionType.quantity)
 });
 
 // src/schema/widgets/checkout-and-beyond/reviews.ts
 import { v7 as uuidv710 } from "uuid";
-import { z as z57 } from "zod";
+import { z as z61 } from "zod";
 
 // src/schema/widgets/checkout-and-beyond/reviewLabels.ts
 var REVIEW_LABELS = {
@@ -3685,68 +3788,69 @@ var REVIEW_LABELS = {
 };
 
 // src/schema/widgets/checkout-and-beyond/reviews.ts
-var CABReviewsSection = z57.object({
+var CABReviewsSection = z61.object({
   ...CABVariableFields,
-  color: z57.string().default("#fadb14"),
+  color: z61.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: z57.object({
-    one: z57.record(z57.string(), z57.string()).default(() => ({ ...REVIEW_LABELS.one })),
-    other: z57.record(z57.string(), z57.string()).default(() => ({ ...REVIEW_LABELS.other }))
+  countLabels: z61.object({
+    one: z61.record(z61.string(), z61.string()).default(() => ({ ...REVIEW_LABELS.one })),
+    other: z61.record(z61.string(), z61.string()).default(() => ({ ...REVIEW_LABELS.other }))
   }).default(() => ({ one: { ...REVIEW_LABELS.one }, other: { ...REVIEW_LABELS.other } })),
-  name: z57.string().optional(),
-  sectionId: z57.uuid().default(() => uuidv710()),
-  sectionType: z57.literal(SectionType.reviews).default(SectionType.reviews),
-  size: z57.enum(reviewsSizes).default(ReviewsSize.default),
+  name: z61.string().optional(),
+  sectionId: z61.uuid().default(() => uuidv710()),
+  sectionType: z61.literal(SectionType.reviews).default(SectionType.reviews),
+  size: z61.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: z57.string().regex(HEX_COLOR_REGEX).default("#fadb14"),
+  strokeColor: z61.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: z57.number().nonnegative().default(0)
+  strokeWidth: z61.number().nonnegative().default(0)
 });
 
 // src/schema/widgets/checkout-and-beyond/separator.ts
 import { v7 as uuidv711 } from "uuid";
-import { z as z58 } from "zod";
-var CABSeparatorSection = z58.object({
+import { z as z62 } from "zod";
+var CABSeparatorSection = z62.object({
   ...CABVariableFields,
-  sectionId: z58.uuid().default(() => uuidv711()),
-  sectionType: z58.literal(SectionType.separator).default(SectionType.separator)
+  sectionId: z62.uuid().default(() => uuidv711()),
+  sectionType: z62.literal(SectionType.separator).default(SectionType.separator)
 });
 
 // src/schema/widgets/checkout-and-beyond/variants.ts
 import { slice } from "es-toolkit/compat";
 import { v7 as uuidv712 } from "uuid";
-import { z as z59 } from "zod";
-var CABVariantsSection = z59.object({
+import { z as z63 } from "zod";
+var CABVariantsSection = z63.object({
   ...CABVariableFields,
-  hideOutOfStockVariants: z59.boolean().default(false),
-  name: z59.string().optional(),
-  sectionId: z59.uuid().default(() => uuidv712()),
-  sectionType: z59.literal(SectionType.variants).default(SectionType.variants),
-  selector: z59.enum(slice(variantSelectors, 0, 3)).default(VariantSelector.menu),
-  variantMode: z59.enum(variantModes).default(VariantMode.multiple)
+  hideOutOfStockVariants: z63.boolean().default(false),
+  name: z63.string().optional(),
+  sectionId: z63.uuid().default(() => uuidv712()),
+  sectionType: z63.literal(SectionType.variants).default(SectionType.variants),
+  selector: z63.enum(slice(variantSelectors, 0, 3)).default(VariantSelector.menu),
+  /** `productGroup` is additive (REB-24817): a renderer without group support must render nothing for it. */
+  variantMode: z63.enum(variantsModes).default(VariantsMode.multiple)
 });
 
 // src/schema/widgets/checkout-and-beyond/shared.ts
-var CABBorder = z60.object({
-  radius: z60.enum(borderRadii).default(BorderRadius.base),
-  style: z60.enum(borderStyles).default(BorderStyle.none),
-  width: z60.enum(borderWidths).default(BorderWidth.base)
+var CABBorder = z64.object({
+  radius: z64.enum(borderRadii).default(BorderRadius.base),
+  style: z64.enum(borderStyles).default(BorderStyle.none),
+  width: z64.enum(borderWidths).default(BorderWidth.base)
 }).default({
   radius: BorderRadius.base,
   style: BorderStyle.none,
   width: BorderWidth.base
 });
-var CABSection = z60.lazy(
-  () => z60.discriminatedUnion("sectionType", [
+var CABSection = z64.lazy(
+  () => z64.discriminatedUnion("sectionType", [
     CABBannerSection,
     CABButtonSection,
     CABCarouselSection,
@@ -3769,41 +3873,41 @@ var CABSection = z60.lazy(
 );
 
 // src/schema/widgets/checkout-and-beyond/layout.ts
-var GridItem = z61.union([z61.literal("auto"), z61.literal("fill"), z61.string().regex(/^\d+%$/), z61.number()]);
-var CABLayoutWrapping = z61.object({
-  breakAt: z61.number().positive(),
-  maxPerLine: z61.number().int().positive()
+var GridItem = z65.union([z65.literal("auto"), z65.literal("fill"), z65.string().regex(/^\d+%$/), z65.number()]);
+var CABLayoutWrapping = z65.object({
+  breakAt: z65.number().positive(),
+  maxPerLine: z65.number().int().positive()
 });
-var CABLayoutSection = z61.object({
+var CABLayoutSection = z65.object({
   ...CABVariableFields,
-  alignment: z61.object({
-    horizontal: z61.enum(horizontalAlignments).default(HorizontalAlignment.start),
-    vertical: z61.enum(verticalAlignments).default(VerticalAlignment.top)
+  alignment: z65.object({
+    horizontal: z65.enum(horizontalAlignments).default(HorizontalAlignment.start),
+    vertical: z65.enum(verticalAlignments).default(VerticalAlignment.top)
   }).default({
     horizontal: HorizontalAlignment.start,
     vertical: VerticalAlignment.top
   }),
-  border: z61.lazy(() => CABBorder),
-  buttonField: z61.enum(buttonFields).optional(),
-  direction: z61.enum(directions).default(Direction.rows),
+  border: z65.lazy(() => CABBorder),
+  buttonField: z65.enum(buttonFields).optional(),
+  direction: z65.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: z61.enum(layoutFrames).optional(),
-  grid: z61.object({
-    columns: z61.union([z61.array(GridItem), z61.undefined()]).default(() => ["auto"]),
-    rows: z61.union([z61.array(GridItem), z61.undefined()]).default(() => ["auto"])
+  frame: z65.enum(layoutFrames).optional(),
+  grid: z65.object({
+    columns: z65.union([z65.array(GridItem), z65.undefined()]).default(() => ["auto"]),
+    rows: z65.union([z65.array(GridItem), z65.undefined()]).default(() => ["auto"])
   }).default({ columns: ["auto"], rows: ["auto"] }).optional(),
-  name: z61.string().optional(),
-  padding: z61.enum(spacings).default(Spacing.none),
-  sectionId: z61.uuid().default(() => uuidv713()),
-  sections: z61.union([z61.array(z61.lazy(() => CABSection)), z61.strictObject({}).transform(() => [])]).default(() => []),
-  sectionType: z61.literal(SectionType.layout).default(SectionType.layout),
-  spacing: z61.enum(spacings).default(Spacing.base),
+  name: z65.string().optional(),
+  padding: z65.enum(spacings).default(Spacing.none),
+  sectionId: z65.uuid().default(() => uuidv713()),
+  sections: z65.union([z65.array(z65.lazy(() => CABSection)), z65.strictObject({}).transform(() => [])]).default(() => []),
+  sectionType: z65.literal(SectionType.layout).default(SectionType.layout),
+  spacing: z65.enum(spacings).default(Spacing.base),
   /** Fire-and-forget impression pixel POSTed once when the section is shown (e.g. a Monetize offer view). */
-  viewUrl: z61.string().optional(),
-  width: z61.number().default(100),
+  viewUrl: z65.string().optional(),
+  width: z65.number().default(100),
   wrapping: CABLayoutWrapping.optional()
 });
 
@@ -3825,8 +3929,8 @@ var UI_LABELS = {
 };
 
 // src/schema/widgets/checkout-and-beyond/root.ts
-var localized = (fallback) => z62.record(z62.string(), z62.string()).default(() => ({ ...fallback })).transform((labels) => Object.keys(labels).length > 0 ? labels : { ...fallback });
-var CABUILabels = z62.object({
+var localized = (fallback) => z66.record(z66.string(), z66.string()).default(() => ({ ...fallback })).transform((labels) => Object.keys(labels).length > 0 ? labels : { ...fallback });
+var CABUILabels = z66.object({
   currentPage: localized(UI_LABELS.currentPage),
   guest: localized(UI_LABELS.guest),
   loadingOptions: localized(UI_LABELS.loadingOptions),
@@ -3851,47 +3955,49 @@ var CABUILabels = z62.object({
   subscriptionOptions: { ...UI_LABELS.subscriptionOptions },
   updating: { ...UI_LABELS.updating }
 }));
-var TargetArea = z62.object({
-  fill: z62.boolean().optional(),
-  flip: z62.enum(["both", "horizontal", "vertical"]).optional(),
-  icon: z62.string(),
-  label: z62.string(),
-  width: z62.string()
+var TargetArea = z66.object({
+  fill: z66.boolean().optional(),
+  flip: z66.enum(["both", "horizontal", "vertical"]).optional(),
+  icon: z66.string(),
+  label: z66.string(),
+  width: z66.string()
 }).default(targetAreas[EditorMode.checkoutExtension][1]);
-var CABTracking = z62.object({
-  enableAttribution: z62.boolean().nullish().transform((value) => value ?? true),
-  enableSource: z62.boolean().nullish().transform((value) => value ?? true),
-  enableWidget: z62.boolean().nullish().transform((value) => value ?? true)
+var CABTracking = z66.object({
+  enableAttribution: z66.boolean().nullish().transform((value) => value ?? true),
+  enableSource: z66.boolean().nullish().transform((value) => value ?? true),
+  enableWidget: z66.boolean().nullish().transform((value) => value ?? true)
 }).nullish().transform((value) => value ?? { enableAttribution: true, enableSource: true, enableWidget: true });
-var CABExperiment = z62.object({
-  elementId: z62.number(),
-  experimentId: z62.number(),
-  experimentType: z62.string(),
-  selectedId: z62.number()
+var CABExperiment = z66.object({
+  elementId: z66.number(),
+  experimentId: z66.number(),
+  experimentType: z66.string(),
+  selectedId: z66.number()
 });
 var CABRootSection = CABLayoutSection.extend({
-  editorMode: z62.enum(editorModes).default(EditorMode.checkoutExtension),
+  editorMode: z66.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: z62.boolean().nullish().transform((value) => value ?? false),
-  storeId: z62.number().nullable().default(null),
+  previewMode: z66.boolean().nullish().transform((value) => value ?? false),
+  storeId: z66.number().nullable().default(null),
   targetArea: TargetArea.nullable(),
   tracking: CABTracking,
-  type: z62.enum(widgetTypes).default(WidgetType.ui_extension_content_block),
+  type: z66.enum(widgetTypes).default(WidgetType.ui_extension_content_block),
   uiLabels: CABUILabels,
-  version: z62.literal(2).default(2),
-  widgetId: z62.number().nullable().default(null)
+  version: z66.literal(2).default(2),
+  widgetId: z66.number().nullable().default(null)
 });
 
 // src/schema/postPurchaseProductView.ts
-var PostPurchaseProductView = z63.union([
-  z63.object({
+var PostPurchaseProductView = z67.union([
+  z67.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: z63.string().nullable() }).refine(
+      display: PreparedPostPurchaseProduct.shape.display.extend({ description: z67.string().nullable() }).refine(
         ({ description, descriptionDocument }) => description === null === (descriptionDocument !== void 0),
         "Exactly one of the plain and rich descriptions is shown"
       )
@@ -3900,33 +4006,35 @@ var PostPurchaseProductView = z63.union([
     sections: CABRootSection,
     variantCatalog: PostPurchaseVariantCatalog.optional()
   }),
-  z63.object({
+  z67.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: z63.null(),
+    sections: z67.null(),
     variantCatalog: PostPurchaseVariantCatalog.optional()
   })
 ]);
 
 // src/schema/postPurchaseProductCollectionView.ts
-var PostPurchaseProductCollectionView = z64.object({
-  members: z64.array(
-    z64.object({
+var PostPurchaseProductCollectionView = z68.object({
+  members: z68.array(
+    z68.object({
       productId: PostPurchaseProductId,
-      productIndex: z64.number().int().nonnegative(),
+      productIndex: z68.number().int().nonnegative(),
       view: PostPurchaseProductView
     })
   )
 });
-var PostPurchaseCollectionChoice = z64.object({
+var PostPurchaseCollectionChoice = z68.object({
   choice: PostPurchaseChoice.optional(),
   productId: PostPurchaseProductId,
   variantId: PostPurchaseVariantSelector.shape.variantId.optional()
 }).strict();
-var PostPurchaseExcludedProductIds = z64.array(PostPurchaseProductId).default([]);
+var PostPurchaseExcludedProductIds = z68.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,
@@ -3939,7 +4047,7 @@ var PostPurchaseQuantityChoice = PostPurchaseCollectionChoice.extend({ quantity:
 var PostPurchaseQuantityPolicy = PostPurchaseSettings.shape.quantityInputs.omit({ defaultQuantity: true }).extend({
   initialQuantity: quantity,
   maxValue: quantity,
-  minValue: z65.literal(0).transform(() => 1).or(quantity)
+  minValue: z69.literal(0).transform(() => 1).or(quantity)
 }).refine(({ maxValue, minValue }) => minValue <= maxValue, "Quantity bounds are reversed");
 
 // src/schema/postPurchaseGroup.ts
@@ -3948,33 +4056,33 @@ var PostPurchaseGroupChoice = PostPurchaseQuantityChoice.extend({
 });
 
 // src/schema/postPurchaseHealth.ts
-import { z as z68 } from "zod";
+import { z as z72 } from "zod";
 
 // src/schema/postPurchaseHealthSchedule.ts
-import { z as z67 } from "zod";
+import { z as z71 } from "zod";
 
 // src/schema/postPurchaseReleaseSchedule.ts
-import { z as z66 } from "zod";
-var postPurchaseTaskNameSchema = (queue, id) => z66.string().regex(new RegExp(`^projects/[a-zA-Z0-9.:-]+/locations/us-central1/queues/${queue}/tasks/${id}$`));
-var SessionReleaseScheduleRequestSchema = z66.strictObject({
+import { z as z70 } from "zod";
+var postPurchaseTaskNameSchema = (queue, id) => z70.string().regex(new RegExp(`^projects/[a-zA-Z0-9.:-]+/locations/us-central1/queues/${queue}/tasks/${id}$`));
+var SessionReleaseScheduleRequestSchema = z70.strictObject({
   deadline: PostPurchaseTimestampSchema,
   orderId: PostPurchaseOrderIdSchema,
   releaseOwner: ReleaseOwnerSchema,
   sessionId: PostPurchaseSessionIdSchema
 });
-var SessionReleaseScheduleResponseSchema = z66.object({
-  data: z66.discriminatedUnion("status", [
+var SessionReleaseScheduleResponseSchema = z70.object({
+  data: z70.discriminatedUnion("status", [
     SessionReleaseScheduleRequestSchema.extend({
-      releaseOwner: z66.literal("rebuy"),
-      status: z66.literal("queued"),
+      releaseOwner: z70.literal("rebuy"),
+      status: z70.literal("queued"),
       taskName: postPurchaseTaskNameSchema("post-purchase-order-hold-release", "[a-f0-9]{64}-release")
     }),
     SessionReleaseScheduleRequestSchema.extend({
-      releaseOwner: z66.literal("shopify"),
-      status: z66.literal("native")
+      releaseOwner: z70.literal("shopify"),
+      status: z70.literal("native")
     })
   ]),
-  successful: z66.literal(true)
+  successful: z70.literal(true)
 });
 
 // src/schema/postPurchaseHealthSchedule.ts
@@ -3983,15 +4091,15 @@ var PostPurchaseHealthTaskNameSchema = postPurchaseTaskNameSchema(
   "post-purchase-health-check",
   "[a-z0-9][a-z0-9-]*--[1-9][0-9]*"
 );
-var HealthScheduleAcknowledgementSchema = z67.strictObject({
+var HealthScheduleAcknowledgementSchema = z71.strictObject({
   data: HealthScheduleSchema.extend({
-    status: z67.literal("queued"),
+    status: z71.literal("queued"),
     taskName: PostPurchaseHealthTaskNameSchema
   }).refine(
     (data) => data.taskName.endsWith(`/tasks/${postPurchaseHealthTaskId(data)}`),
     "taskName must be this order's health task"
   ),
-  successful: z67.literal(true)
+  successful: z71.literal(true)
 });
 
 // src/schema/postPurchaseHealth.ts
@@ -4000,90 +4108,93 @@ var HealthFactSchema = HealthScheduleSchema.pick({
   operationId: true,
   removePartialOrder: true
 });
-var HealthScheduleReceiptSchema = z68.strictObject({
+var HealthScheduleReceiptSchema = z72.strictObject({
   recordedAt: PostPurchaseTimestampSchema,
   taskName: PostPurchaseHealthTaskNameSchema
 });
-var StoredHealthFactSchema = HealthFactSchema.extend({ scheduleReceipt: HealthScheduleReceiptSchema.optional() });
+var StoredHealthFactSchema = HealthFactSchema.extend({
+  checkoutToken: HealthScheduleSchema.shape.checkoutToken.optional(),
+  scheduleReceipt: HealthScheduleReceiptSchema.optional()
+});
 var HealthAttemptSchema = StoredHealthFactSchema.extend({
   attemptedAt: PostPurchaseTimestampSchema,
-  attemptId: z68.uuid(),
-  status: z68.literal("attempted")
+  attemptId: z72.uuid(),
+  status: z72.literal("attempted")
 });
 var HealthResultSchema = HealthAttemptSchema.extend({
   finishedAt: PostPurchaseTimestampSchema,
-  status: z68.enum(["returned", "unknown"])
+  status: z72.enum(["returned", "unknown"])
 });
-var HealthStateSchema = z68.union([
-  StoredHealthFactSchema.extend({ status: z68.literal("pending") }),
+var HealthStateSchema = z72.union([
+  StoredHealthFactSchema.extend({ status: z72.literal("pending") }),
   HealthAttemptSchema,
   HealthResultSchema
 ]);
 var HealthPrepareRequestSchema = DecideRequestSchema.extend({
   operationId: HealthScheduleSchema.shape.operationId
 }).strict();
-var HealthPrepareResponseSchema = z68.object({ data: HealthScheduleSchema, successful: z68.literal(true) });
-var HealthClaimRequestSchema = z68.strictObject({
+var HealthPrepareResponseSchema = z72.object({ data: HealthScheduleSchema, successful: z72.literal(true) });
+var HealthClaimRequestSchema = z72.strictObject({
   orderId: PostPurchaseOrderIdSchema,
-  removePartialOrder: z68.boolean(),
+  removePartialOrder: z72.boolean(),
   shop: ShopifyDomainSchema
 });
 var HealthClaimFactSchema = HealthClaimRequestSchema.extend({
   healthScheduledAt: HealthFactSchema.shape.healthScheduledAt
 });
-var HealthClaimResponseSchema = z68.object({
-  data: z68.union([
-    z68.strictObject({ status: z68.literal("missing") }),
-    HealthClaimFactSchema.extend({ status: z68.enum(["pending", "attempted", "returned", "unknown"]) }),
-    HealthClaimFactSchema.extend({ attemptId: HealthAttemptSchema.shape.attemptId, status: z68.literal("claimed") })
+var HealthClaimResponseSchema = z72.object({
+  data: z72.union([
+    z72.strictObject({ status: z72.literal("missing") }),
+    HealthClaimFactSchema.extend({ status: z72.enum(["pending", "attempted", "returned", "unknown"]) }),
+    HealthClaimFactSchema.extend({ attemptId: HealthAttemptSchema.shape.attemptId, status: z72.literal("claimed") })
   ]),
-  successful: z68.literal(true)
+  successful: z72.literal(true)
 });
 var HealthResultRequestSchema = HealthClaimRequestSchema.extend({
   attemptId: HealthAttemptSchema.shape.attemptId,
   outcome: HealthResultSchema.shape.status
 });
-var HealthResultResponseSchema = z68.object({
+var HealthResultResponseSchema = z72.object({
   data: HealthClaimFactSchema.extend({
     finishedAt: HealthResultSchema.shape.finishedAt,
     status: HealthResultSchema.shape.status
   }),
-  successful: z68.literal(true)
+  successful: z72.literal(true)
 });
 
 // src/schema/postPurchaseLifecycle.ts
-import { z as z69 } from "zod";
-var Presentation = z69.strictObject({
+import { z as z73 } from "zod";
+var Presentation = z73.strictObject({
   member: PostPurchaseMemberIdentity,
   selectedProductId: PostPurchaseMemberIdentity.shape.productId.optional(),
   variant: PostPurchaseVariantSelector
 });
 var LifecycleObservationRequestSchema = DecideRequestSchema.extend({
   entryRevision: PostPurchaseProgressSchema.shape.entryRevision,
-  eventType: z69.enum(["OFFER_VIEWED", "OFFER_TIMER_EXPIRED"]),
+  eventType: z73.enum(["OFFER_VIEWED", "OFFER_TIMER_EXPIRED"]),
   presentation: Presentation.nullable(),
   progressRevision: PostPurchaseProgressSchema.shape.revision,
-  requestId: z69.uuid()
+  requestId: z73.uuid()
 }).strict().refine(
   ({ eventType, presentation }) => eventType !== "OFFER_VIEWED" || presentation !== null,
   "Viewed observations require a presented product"
 );
-var LifecycleObservationResponseSchema = z69.object({
-  data: z69.strictObject({
+var LifecycleObservationResponseSchema = z73.object({
+  data: z73.strictObject({
     requestId: LifecycleObservationRequestSchema.shape.requestId,
-    status: z69.union([AcceptedEventOutcomeSchema, z69.literal("unavailable")])
+    status: z73.union([AcceptedEventOutcomeSchema, z73.literal("unavailable")])
   }),
-  successful: z69.literal(true)
+  successful: z73.literal(true)
 });
 
 // src/schema/postPurchaseOffer.ts
-import { z as z71 } from "zod";
+import { z as z75 } from "zod";
 
 // src/schema/postPurchaseSkipTrace.ts
-import { z as z70 } from "zod";
+import { z as z74 } from "zod";
 var POST_PURCHASE_SKIP_LIMIT = 32;
-var PostPurchaseSkipTraceSchema = z70.array(
-  z70.object({
+var PostPurchaseSkipTraceSchema = z74.array(
+  z74.object({
     entry: DecisionEntrySchema,
     reason: PostPurchaseSkipReasonSchema
   })
@@ -4091,66 +4202,66 @@ var PostPurchaseSkipTraceSchema = z70.array(
 
 // src/schema/postPurchaseOffer.ts
 var OfferPreparationRequestSchema = DecideRequestSchema.strict();
-var OfferPreparationResponseSchema = z71.object({
-  data: z71.object({ attemptedSkips: PostPurchaseSkipTraceSchema.optional(), progress: PostPurchaseProgressSchema }),
-  successful: z71.literal(true)
+var OfferPreparationResponseSchema = z75.object({
+  data: z75.object({ attemptedSkips: PostPurchaseSkipTraceSchema.optional(), progress: PostPurchaseProgressSchema }),
+  successful: z75.literal(true)
 });
 
 // src/schema/postPurchaseOfferEligibility.ts
-import { z as z72 } from "zod";
-var selection = PreparedPostPurchaseProduct.shape.selection;
-var PostPurchaseOfferSkipReason = z72.enum(["empty", "no-eligible-subscription"]);
-var PostPurchaseOfferEligibilityContext = z72.object({
+import { z as z76 } from "zod";
+var selection2 = PreparedPostPurchaseProduct.shape.selection;
+var PostPurchaseOfferSkipReason = z76.enum(["empty", "no-eligible-subscription"]);
+var PostPurchaseOfferEligibilityContext = z76.object({
   excludedProductIds: PostPurchaseExcludedProductIds,
-  originalLineItems: z72.array(selection.pick({ productId: true, sellingPlanId: true, variantId: true }))
+  originalLineItems: z76.array(selection2.pick({ productId: true, sellingPlanId: true, variantId: true }))
 });
-var PostPurchaseOfferEligibility = z72.discriminatedUnion("status", [
-  z72.object({
-    members: z72.array(
-      z72.object({ productId: selection.shape.productId, productIndex: z72.number().int().nonnegative() })
+var PostPurchaseOfferEligibility = z76.discriminatedUnion("status", [
+  z76.object({
+    members: z76.array(
+      z76.object({ productId: selection2.shape.productId, productIndex: z76.number().int().nonnegative() })
     ),
-    status: z72.literal("retain")
+    status: z76.literal("retain")
   }),
-  z72.object({ reason: PostPurchaseOfferSkipReason, status: z72.literal("skip") }),
-  z72.object({ reason: z72.literal("eligible-upgrade").optional(), status: z72.literal("unavailable") })
+  z76.object({ reason: PostPurchaseOfferSkipReason, status: z76.literal("skip") }),
+  z76.object({ reason: z76.literal("eligible-upgrade").optional(), status: z76.literal("unavailable") })
 ]);
 
 // src/schema/postPurchaseOfferPresentation.ts
-import { z as z73 } from "zod";
+import { z as z77 } from "zod";
 var language2 = PostPurchaseSettings.shape.language.shape.global.unwrap().unwrap();
-var PostPurchaseOfferPresentation = z73.strictObject({
+var PostPurchaseOfferPresentation = z77.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 = z73.object({
-  data: z73.strictObject({
+var OfferPresentationResponseSchema = z77.object({
+  data: z77.strictObject({
     presentation: PostPurchaseOfferPresentation.nullable(),
     progress: PostPurchaseProgressSchema.nullable(),
     serverNow: PostPurchaseTimestampSchema
   }),
-  successful: z73.literal(true)
+  successful: z77.literal(true)
 });
 
 // src/schema/postPurchaseOrderDecision.ts
-import { z as z74 } from "zod";
-var OrderDecisionSchema = z74.discriminatedUnion("owner", [
-  z74.object({ owner: z74.literal("session"), sessionId: PostPurchaseSessionIdSchema }),
-  z74.object({ owner: z74.literal("release"), sessionId: z74.null() })
+import { z as z78 } from "zod";
+var OrderDecisionSchema = z78.discriminatedUnion("owner", [
+  z78.object({ owner: z78.literal("session"), sessionId: PostPurchaseSessionIdSchema }),
+  z78.object({ owner: z78.literal("release"), sessionId: z78.null() })
 ]);
 
 // src/schema/postPurchasePolicy.ts
-import { z as z75 } from "zod";
-var HoldSettingSchema = z75.discriminatedUnion("enabled", [
-  z75.object({ durationMinutes: z75.number().int().min(1).max(60), enabled: z75.literal(true) }),
-  z75.object({ durationMinutes: z75.null(), enabled: z75.literal(false) })
+import { z as z79 } from "zod";
+var HoldSettingSchema = z79.discriminatedUnion("enabled", [
+  z79.object({ durationMinutes: z79.number().int().min(1).max(60), enabled: z79.literal(true) }),
+  z79.object({ durationMinutes: z79.null(), enabled: z79.literal(false) })
 ]);
-var TimingSettingsSchema = z75.object({ flowHold: HoldSettingSchema, shopHold: HoldSettingSchema });
+var TimingSettingsSchema = z79.object({ flowHold: HoldSettingSchema, shopHold: HoldSettingSchema });
 var SessionPolicySchema = TimingSettingsSchema.extend({
-  durationMinutes: z75.number().int().min(1).max(60).nullable(),
-  source: z75.enum(["shop", "flow", "native"])
+  durationMinutes: z79.number().int().min(1).max(60).nullable(),
+  source: z79.enum(["shop", "flow", "native"])
 }).refine(
   (policy) => {
     const expectedSource = policy.shopHold.enabled ? "shop" : policy.flowHold.enabled ? "flow" : "native";
@@ -4164,8 +4275,8 @@ var SessionPolicySchema = TimingSettingsSchema.extend({
 );
 
 // src/schema/postPurchasePreparationOptions.ts
-import { z as z76 } from "zod";
-var PostPurchasePreparationOptions = z76.object({
+import { z as z80 } from "zod";
+var PostPurchasePreparationOptions = z80.object({
   choice: PostPurchaseChoice.optional(),
   member: PostPurchaseMemberSelector.strict().optional(),
   quantity: PreparedPostPurchaseProduct.shape.selection.shape.quantity.optional(),
@@ -4177,8 +4288,8 @@ var PostPurchasePreparationOptions = z76.object({
 );
 
 // src/schema/postPurchaseProductSettings.ts
-import { z as z77 } from "zod";
-var amount = z77.union([z77.number().nonnegative(), PostPurchaseAmount.transform(Number)]);
+import { z as z81 } from "zod";
+var amount = z81.union([z81.number().nonnegative(), PostPurchaseAmount.transform(Number)]);
 var PostPurchaseProductSettings = PostPurchaseSettings.pick({
   discountedFrom: true,
   language: true,
@@ -4190,62 +4301,66 @@ var PostPurchaseProductSettings = PostPurchaseSettings.pick({
   subscriptionIsDefault: true,
   upgradeToSubscription: true
 }).extend({
-  advance: z77.unknown().default({}),
-  blocks: z77.array(z77.unknown()).optional(),
+  advance: z81.unknown().default({}),
+  blocks: z81.array(z81.unknown()).optional(),
   discount: PostPurchaseSettings.shape.discount.extend({ amount: amount.default(30) }),
-  integrations: z77.unknown().default({}),
+  integrations: z81.unknown().default({}),
   shipping: PostPurchaseSettings.shape.shipping.extend({ amount: amount.default(10) }),
-  styles: z77.unknown().default({}),
+  styles: z81.unknown().default({}),
   subImages: PostPurchaseSettings.shape.subImages.catch(null),
-  subscription: z77.unknown().default(PostPurchaseSettings.shape.subscription.parse(void 0))
+  subscription: z81.unknown().default(PostPurchaseSettings.shape.subscription.parse(void 0))
 });
 
 // src/schema/postPurchaseRecovery.ts
-import { z as z78 } from "zod";
+import { z as z82 } from "zod";
 var PurchaseRecoveryRequestSchema = DecideRequestSchema.strict();
-var PurchaseRecoveryResponseSchema = z78.object({
-  data: z78.object({
-    operation: z78.object({
+var PurchaseRecoveryResponseSchema = z82.object({
+  data: z82.object({
+    operation: z82.object({
       observation: RecordedPurchaseObservationSchema.nullable(),
-      operationId: PurchaseReceiptSchema.shape.operationId
-    }).strict().nullable(),
+      operationId: PurchaseReceiptSchema.shape.operationId,
+      upgrade: UpgradeProgressSchema.optional()
+    }).strict().refine(({ operationId, upgrade }) => !upgrade || upgrade.operationId === operationId, {
+      message: "Upgrade progress belongs to its operation",
+      path: ["upgrade", "operationId"]
+    }).nullable(),
     progress: PostPurchaseProgressSchema.nullable().optional()
   }),
-  successful: z78.literal(true)
+  successful: z82.literal(true)
 });
 
 // src/schema/postPurchaseReleaseClaim.ts
-import { z as z79 } from "zod";
+import { z as z83 } from "zod";
 var ReleaseClaimRequestSchema = ReleaseAuthorityRequestSchema;
-var ReleaseClaimResponseSchema = z79.object({
-  data: z79.discriminatedUnion("status", [
-    z79.object({ status: z79.literal("release-permitted") }),
+var ReleaseClaimResponseSchema = z83.object({
+  data: z83.discriminatedUnion("status", [
+    z83.object({ status: z83.literal("release-permitted") }),
     PendingReleaseAuthoritySchema,
     ReadyReleaseAuthoritySchema
   ]),
-  successful: z79.literal(true)
+  successful: z83.literal(true)
 });
 
 // src/schema/postPurchaseSelection.ts
-import { z as z80 } from "zod";
+import { z as z84 } from "zod";
 var SelectionClaimsSchema = DecideRequestSchema.extend({
   appId: PostPurchaseAppIdSchema,
   entry: DecisionEntrySchema,
-  iss: z80.literal("rebuy-api"),
-  purpose: z80.literal("post-purchase-selection")
+  iss: z84.literal("rebuy-api"),
+  purpose: z84.literal("post-purchase-selection")
 });
 var SessionStartRequestSchema = DecideRequestSchema.extend({
-  selectionToken: z80.string().min(1).max(8192).optional()
+  selectionToken: z84.string().min(1).max(8192).optional()
 }).strict();
 
 // src/schema/postPurchaseSession.ts
-import { z as z81 } from "zod";
+import { z as z85 } from "zod";
 var SessionIdentitySchema = DecideRequestSchema.extend({ appId: PostPurchaseAppIdSchema });
-var SessionOrderTimingSchema = z81.object({
+var SessionOrderTimingSchema = z85.object({
   nativeDeadline: PostPurchaseTimestampSchema,
   orderCreatedAt: PostPurchaseTimestampSchema,
   orderId: PostPurchaseOrderIdSchema,
-  timingSource: z81.literal("shopify-order-created-at")
+  timingSource: z85.literal("shopify-order-created-at")
 });
 var ReadySessionTimingSchema = SessionOrderTimingSchema.extend({
   deadline: PostPurchaseTimestampSchema,
@@ -4262,33 +4377,33 @@ var ReadySessionTimingSchema = SessionOrderTimingSchema.extend({
   message: "deadline must not exceed nativeDeadline",
   path: ["deadline"]
 });
-var SessionStartResponseSchema = z81.object({
-  data: z81.object({
-    phase: z81.literal("render"),
+var SessionStartResponseSchema = z85.object({
+  data: z85.object({
+    phase: z85.literal("render"),
     serverNow: PostPurchaseTimestampSchema,
     session: ReadySessionTimingSchema,
-    workflowPhase: z81.literal("start")
+    workflowPhase: z85.literal("start")
   }),
-  successful: z81.literal(true)
+  successful: z85.literal(true)
 });
 
 // src/schema/postPurchaseShadow.ts
-import { z as z82 } from "zod";
-var PostPurchaseShadowSelectionSchema = z82.discriminatedUnion("verdict", [
-  z82.object({ entry: DecisionEntrySchema, verdict: z82.literal("render") }),
-  z82.object({ verdict: z82.literal("skip") })
+import { z as z86 } from "zod";
+var PostPurchaseShadowSelectionSchema = z86.discriminatedUnion("verdict", [
+  z86.object({ entry: DecisionEntrySchema, verdict: z86.literal("render") }),
+  z86.object({ verdict: z86.literal("skip") })
 ]);
-var PostPurchaseShadowReportFields = z82.object({
-  differences: z82.array(z82.enum(["verdict", "entry", "targeting", "incomplete-capture", "unsupported-configuration"])).refine((differences) => new Set(differences).size === differences.length, {
+var PostPurchaseShadowReportFields = z86.object({
+  differences: z86.array(z86.enum(["verdict", "entry", "targeting", "incomplete-capture", "unsupported-configuration"])).refine((differences) => new Set(differences).size === differences.length, {
     message: "differences must not contain duplicate entries"
   }),
   legacySelection: PostPurchaseShadowSelectionSchema,
-  phase: z82.literal("shouldRender"),
-  sampleId: z82.string(),
+  phase: z86.literal("shouldRender"),
+  sampleId: z86.string(),
   serverSelection: PostPurchaseShadowSelectionSchema.optional(),
-  status: z82.enum(["match", "diverged", "incomplete"]),
-  targetingFlowIds: z82.array(z82.number().int().positive()),
-  workflowPhase: z82.literal("decide")
+  status: z86.enum(["match", "diverged", "incomplete"]),
+  targetingFlowIds: z86.array(z86.number().int().positive()),
+  workflowPhase: z86.literal("decide")
 });
 var PostPurchaseShadowReportSchema = PostPurchaseShadowReportFields.refine(
   (report) => report.status !== "match" || report.differences.length === 0,
@@ -4301,21 +4416,10 @@ var PostPurchaseShadowReportSchema = PostPurchaseShadowReportFields.refine(
   path: ["status"]
 });
 
-// src/schema/postPurchaseSubscriptionDisplay.ts
-import { z as z83 } from "zod";
-var Minor2 = z83.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
-var PostPurchaseSubscriptionDisplay = z83.object({
-  comparisonMinor: Minor2,
-  currencyCode: z83.string().regex(/^[A-Z]{3}$/),
-  priceMinor: Minor2,
-  savingMinor: Minor2,
-  savingPercent: z83.number().int().min(0).max(100)
-});
-
 // src/schema/postPurchaseSubscriptionProduct.ts
-import { z as z84 } from "zod";
+import { z as z87 } from "zod";
 var PreparedPostPurchaseSubscription = PreparedPostPurchaseProduct.extend({
-  selection: PreparedPostPurchaseProduct.shape.selection.extend({ sellingPlanId: z84.number().int().positive() }),
+  selection: PreparedPostPurchaseProduct.shape.selection.extend({ sellingPlanId: z87.number().int().positive() }),
   terms: PreparedPostPurchaseProduct.shape.terms.extend({
     subscription: PostPurchaseSubscriptionTerms
   }).refine(
@@ -4328,108 +4432,108 @@ var readPostPurchaseSubscription = (prepared) => {
 };
 
 // src/schema/postPurchaseTransition.ts
-import { z as z85 } from "zod";
+import { z as z88 } from "zod";
 var OfferTransitionRequestSchema = DecideRequestSchema.extend({
   entryRevision: PostPurchaseProgressSchema.shape.entryRevision,
   progressRevision: PostPurchaseProgressSchema.shape.revision
 }).strict();
-var OfferTransitionResponseSchema = z85.object({
-  data: z85.object({
+var OfferTransitionResponseSchema = z88.object({
+  data: z88.object({
     attemptedSkips: PostPurchaseSkipTraceSchema.optional(),
     progress: PostPurchaseProgressSchema,
-    status: z85.enum(["advanced", "no-child", "unavailable"])
+    status: z88.enum(["advanced", "no-child", "unavailable"])
   }),
-  successful: z85.literal(true)
+  successful: z88.literal(true)
 });
 
 // src/schema/postPurchaseVariantDefault.ts
-import { z as z86 } from "zod";
+import { z as z89 } from "zod";
 var values = PostPurchaseVariantValues.partial().extend({
   option1: PostPurchaseVariantValues.shape.option1.nullish()
 });
 var variant = values.extend({
   id: PostPurchaseVariantId,
-  inventoryManagement: z86.string().nullable(),
-  inventoryPolicy: z86.string(),
-  inventoryQuantity: z86.number()
+  inventoryManagement: z89.string().nullable(),
+  inventoryPolicy: z89.string(),
+  inventoryQuantity: z89.number()
 });
-var options = z86.array(PostPurchaseVariantOption.pick({ name: true, values: true }));
-var PostPurchaseVariantDefaultProduct = z86.object({
+var options = z89.array(PostPurchaseVariantOption.pick({ name: true, values: true }));
+var PostPurchaseVariantDefaultProduct = z89.object({
   id: PostPurchaseProductId,
   options,
   selectedVariant: variant.optional(),
-  variants: z86.array(variant)
+  variants: z89.array(variant)
 });
 var PostPurchaseVariantDefaultSettings = PostPurchaseSettings.shape.productOptions.pick({
   hideOutOfStockVariants: true,
   matchVariant: true
 });
-var PostPurchaseOrderAttributes = z86.record(z86.string(), z86.array(z86.string())).default({});
-var PostPurchaseOriginalVariants = z86.array(
-  z86.object({ productId: PostPurchaseProductId, variantId: PostPurchaseVariantId })
+var PostPurchaseOrderAttributes = z89.record(z89.string(), z89.array(z89.string())).default({});
+var PostPurchaseOriginalVariants = z89.array(
+  z89.object({ productId: PostPurchaseProductId, variantId: PostPurchaseVariantId })
 );
-var PostPurchaseAttributeProducts = z86.array(
-  z86.object({ id: PostPurchaseProductId, options, variants: z86.array(values.extend({ id: PostPurchaseVariantId })) })
+var PostPurchaseAttributeProducts = z89.array(
+  z89.object({ id: PostPurchaseProductId, options, variants: z89.array(values.extend({ id: PostPurchaseVariantId })) })
 );
 
 // src/schema/postPurchaseVariantDefaultContext.ts
-import { z as z87 } from "zod";
-var PostPurchaseVariantDefaultContext = z87.object({
-  enrichedLineItems: z87.unknown().optional(),
+import { z as z90 } from "zod";
+var PostPurchaseVariantDefaultContext = z90.object({
+  enrichedLineItems: z90.unknown().optional(),
   originalVariants: PostPurchaseOriginalVariants
 });
 
 // src/schema/shopConfig.ts
-import { z as z88 } from "zod";
-var ShopConfig = z88.object({
-  activeExperiments: z88.array(
-    z88.object({
-      data: z88.array(
-        z88.object({
-          aliasName: z88.string(),
-          cssInput: z88.string().nullish(),
-          elementId: z88.coerce.number(),
-          id: z88.coerce.number(),
-          javascriptInput: z88.string().nullish(),
-          traffic: z88.coerce.number()
+import { z as z91 } from "zod";
+var ShopConfig = z91.object({
+  activeExperiments: z91.array(
+    z91.object({
+      data: z91.array(
+        z91.object({
+          aliasName: z91.string(),
+          cssInput: z91.string().nullish(),
+          elementId: z91.coerce.number(),
+          id: z91.coerce.number(),
+          javascriptInput: z91.string().nullish(),
+          traffic: z91.coerce.number()
         })
       ),
-      id: z88.coerce.number(),
-      name: z88.string(),
-      pageTarget: z88.string().nullable(),
-      pageTargetUrl: z88.string().nullable(),
-      placeholderId: z88.coerce.number().nullable(),
-      type: z88.string()
+      id: z91.coerce.number(),
+      name: z91.string(),
+      pageTarget: z91.string().nullable(),
+      pageTargetUrl: z91.string().nullable(),
+      placeholderId: z91.coerce.number().nullable(),
+      type: z91.string()
     })
   ),
-  activePackages: z88.array(
-    z88.object({
-      cancelledAt: z88.string().nullable(),
-      id: z88.number(),
-      installedAt: z88.string().nullable(),
-      isActive: z88.boolean(),
-      isBillable: z88.boolean(),
-      packageId: z88.number(),
-      packageName: z88.string(),
-      shortName: z88.string(),
-      trialDays: z88.number(),
-      uninstalledAt: z88.string().nullable()
+  activePackages: z91.array(
+    z91.object({
+      cancelledAt: z91.string().nullable(),
+      id: z91.number(),
+      installedAt: z91.string().nullable(),
+      isActive: z91.boolean(),
+      isBillable: z91.boolean(),
+      packageId: z91.number(),
+      packageName: z91.string(),
+      shortName: z91.string(),
+      trialDays: z91.number(),
+      uninstalledAt: z91.string().nullable()
     })
   ),
-  apiKey: z88.string(),
-  billingVersion: z88.string().nullable(),
-  cacheKey: z88.coerce.number(),
-  carousel: z88.enum(["flickity", "splide"]),
-  currency: z88.string(),
-  currencySymbol: z88.string(),
-  domain: z88.string(),
-  enabledJquery: z88.boolean(),
-  enabledPresentmentCurrencies: z88.array(z88.string()),
-  hasSmartCollectionsEnabled: z88.boolean(),
-  hasSmartSearchEnabled: z88.boolean(),
-  id: z88.coerce.number(),
-  integrations: z88.record(
-    z88.enum([
+  apiKey: z91.string(),
+  billingVersion: z91.string().nullable(),
+  cacheKey: z91.coerce.number(),
+  carousel: z91.enum(["flickity", "splide"]),
+  currency: z91.string(),
+  currencySymbol: z91.string(),
+  domain: z91.string(),
+  enabledJquery: z91.boolean(),
+  enabledPresentmentCurrencies: z91.array(z91.string()),
+  hasSmartCollectionsEnabled: z91.boolean(),
+  hasSmartSearchEnabled: z91.boolean(),
+  id: z91.coerce.number(),
+  integrations: z91.record(
+    z91.enum([
       "attentive",
       "judgeme",
       "junip",
@@ -4442,170 +4546,170 @@ var ShopConfig = z88.object({
       "stamped",
       "yotpo"
     ]),
-    z88.union([z88.boolean(), z88.unknown()])
+    z91.union([z91.boolean(), z91.unknown()])
   ),
-  markets: z88.object({
-    enabled: z88.boolean()
+  markets: z91.object({
+    enabled: z91.boolean()
   }),
-  monetize: z88.object({
-    publisherKey: z88.string().nullable()
+  monetize: z91.object({
+    publisherKey: z91.string().nullable()
   }).nullish(),
-  moneyFormat: z88.string(),
-  myshopifyDomain: z88.string(),
-  primaryLocale: z88.string(),
-  productGroupsEnabled: z88.enum(["no", "yes"]).transform((value) => value === "yes"),
-  rechargeCustomDomain: z88.string().nullable(),
-  sellingPlansEnabled: z88.boolean(),
-  shopId: z88.number(),
-  shopifySellingPlansEnabled: z88.boolean(),
-  shopName: z88.string(),
-  storefrontAccessToken: z88.string().nullable(),
-  useRebuyIcons: z88.boolean()
+  moneyFormat: z91.string(),
+  myshopifyDomain: z91.string(),
+  primaryLocale: z91.string(),
+  productGroupsEnabled: z91.enum(["no", "yes"]).transform((value) => value === "yes"),
+  rechargeCustomDomain: z91.string().nullable(),
+  sellingPlansEnabled: z91.boolean(),
+  shopId: z91.number(),
+  shopifySellingPlansEnabled: z91.boolean(),
+  shopName: z91.string(),
+  storefrontAccessToken: z91.string().nullable(),
+  useRebuyIcons: z91.boolean()
 });
 
 // src/schema/userConfig.ts
-import { z as z89 } from "zod";
-var UserConfig = z89.object({
+import { z as z92 } from "zod";
+var UserConfig = z92.object({
   shop: ShopConfig,
   /**
    * `.catch(undefined)` is the safety bar: smart-cart shape drift can NEVER fail `fetchUserConfig`,
    * which resolves the apiKey for every offers/monetize/analytics/gift request.
    */
   smartCart: SmartCartConfig.nullish().catch(void 0),
-  smartFlows: z89.array(z89.unknown())
+  smartFlows: z92.array(z92.unknown())
 });
 
 // src/schema/widgetData.ts
-import { z as z98 } from "zod";
+import { z as z101 } from "zod";
 
 // src/schema/widgets/abTestingPlaceholder.ts
-import { z as z90 } from "zod";
-var ABTestingPlaceholder = z90.looseObject({
-  type: z90.literal("placeholder")
+import { z as z93 } from "zod";
+var ABTestingPlaceholder = z93.looseObject({
+  type: z93.literal("placeholder")
 });
 
 // src/schema/widgets/checkoutExtension.ts
-import { z as z91 } from "zod";
-var CheckoutExtension = z91.looseObject({
-  type: z91.literal(WidgetType.shopify_checkout_extension).default(WidgetType.shopify_checkout_extension)
+import { z as z94 } from "zod";
+var CheckoutExtension = z94.looseObject({
+  type: z94.literal(WidgetType.shopify_checkout_extension).default(WidgetType.shopify_checkout_extension)
 });
 
 // src/schema/widgets/contentBlock.ts
-import { z as z92 } from "zod";
-var ContentBlockV1 = z92.object({
-  blockSpacing: z92.enum(spacings).optional(),
-  imageBlocks: z92.union([
-    z92.array(
-      z92.object({
-        altText: z92.string().nullable(),
-        description: z92.string().nullable(),
-        id: z92.uuid(),
-        imagePlacement: z92.enum(["top", "right", "bottom", "left"]),
-        imageSize: z92.number(),
-        imageUrl: z92.url(),
-        textAlignment: z92.enum(["left", "center", "right"]),
+import { z as z95 } from "zod";
+var ContentBlockV1 = z95.object({
+  blockSpacing: z95.enum(spacings).optional(),
+  imageBlocks: z95.union([
+    z95.array(
+      z95.object({
+        altText: z95.string().nullable(),
+        description: z95.string().nullable(),
+        id: z95.uuid(),
+        imagePlacement: z95.enum(["top", "right", "bottom", "left"]),
+        imageSize: z95.number(),
+        imageUrl: z95.url(),
+        textAlignment: z95.enum(["left", "center", "right"]),
         /** Inline scale only: an image caption can never be a block-level heading. */
-        textSize: z92.enum(inlineTextSizeNames)
+        textSize: z95.enum(inlineTextSizeNames)
       })
     ),
-    z92.strictObject({}).transform(() => [])
+    z95.strictObject({}).transform(() => [])
   ]).optional(),
-  imageLayout: z92.enum(["row", "column"]).optional(),
-  language: z92.object({
-    description: z92.string(),
-    superTitle: z92.string(),
-    title: z92.string()
+  imageLayout: z95.enum(["row", "column"]).optional(),
+  language: z95.object({
+    description: z95.string(),
+    superTitle: z95.string(),
+    title: z95.string()
   }),
-  previewMode: z92.boolean(),
-  type: z92.literal(WidgetType.ui_extension_content_block).default(WidgetType.ui_extension_content_block),
-  version: z92.literal(1)
+  previewMode: z95.boolean(),
+  type: z95.literal(WidgetType.ui_extension_content_block).default(WidgetType.ui_extension_content_block),
+  version: z95.literal(1)
 });
-var ContentBlock = z92.discriminatedUnion("version", [
+var ContentBlock = z95.discriminatedUnion("version", [
   ContentBlockV1,
   CABRootSection.extend({
-    type: z92.literal(WidgetType.ui_extension_content_block).default(WidgetType.ui_extension_content_block)
+    type: z95.literal(WidgetType.ui_extension_content_block).default(WidgetType.ui_extension_content_block)
   })
 ]);
 
 // src/schema/widgets/giftWithPurchase.ts
-import { z as z93 } from "zod";
-var GiftWithPurchase = z93.looseObject({
-  type: z93.literal(WidgetType.gift_with_purchase).default(WidgetType.gift_with_purchase)
+import { z as z96 } from "zod";
+var GiftWithPurchase = z96.looseObject({
+  type: z96.literal(WidgetType.gift_with_purchase).default(WidgetType.gift_with_purchase)
 });
 
 // src/schema/widgets/lineItemEditor.ts
-import { z as z94 } from "zod";
-var LineItemEditorSwitchLanguageV1 = z94.object({
-  downgradeToOneTimeLabel: z94.string().optional(),
+import { z as z97 } from "zod";
+var LineItemEditorSwitchLanguageV1 = z97.object({
+  downgradeToOneTimeLabel: z97.string().optional(),
   /** Frequency-option template (`{{frequency}}`/`{{interval}}`) for the plan select. */
-  subscriptionOptionLabel: z94.string().optional(),
-  upgradeToSubscriptionLabel: z94.string().optional(),
-  upgradeToSubscriptionWithoutDiscountLabel: z94.string().optional()
+  subscriptionOptionLabel: z97.string().optional(),
+  upgradeToSubscriptionLabel: z97.string().optional(),
+  upgradeToSubscriptionWithoutDiscountLabel: z97.string().optional()
 });
-var LineItemEditorV1 = z94.object({
+var LineItemEditorV1 = z97.object({
   /** Legacy `getStyles` button style; the converter carries a valid kind, defaulting to `plain`. */
-  button: z94.object({ kind: z94.enum(["plain", "primary", "secondary"]).optional() }).optional(),
-  previewMode: z94.boolean().optional(),
-  switchToSubscription: z94.object({
-    disableDowngrade: z94.boolean().optional(),
+  button: z97.object({ kind: z97.enum(["plain", "primary", "secondary"]).optional() }).optional(),
+  previewMode: z97.boolean().optional(),
+  switchToSubscription: z97.object({
+    disableDowngrade: z97.boolean().optional(),
     language: LineItemEditorSwitchLanguageV1.optional()
   }).optional(),
-  switchToSubscriptionEnabled: z94.boolean().optional(),
-  tracking: z94.object({
-    enableAttribution: z94.boolean().optional(),
-    enableSource: z94.boolean().optional(),
-    enableWidget: z94.boolean().optional()
+  switchToSubscriptionEnabled: z97.boolean().optional(),
+  tracking: z97.object({
+    enableAttribution: z97.boolean().optional(),
+    enableSource: z97.boolean().optional(),
+    enableWidget: z97.boolean().optional()
   }).optional(),
-  type: z94.literal(WidgetType.ui_extension_line_item_editor).default(WidgetType.ui_extension_line_item_editor),
-  version: z94.literal(1)
+  type: z97.literal(WidgetType.ui_extension_line_item_editor).default(WidgetType.ui_extension_line_item_editor),
+  version: z97.literal(1)
 });
-var LineItemEditor = z94.discriminatedUnion("version", [
+var LineItemEditor = z97.discriminatedUnion("version", [
   LineItemEditorV1,
   CABRootSection.extend({
-    type: z94.literal(WidgetType.ui_extension_line_item_editor).default(WidgetType.ui_extension_line_item_editor)
+    type: z97.literal(WidgetType.ui_extension_line_item_editor).default(WidgetType.ui_extension_line_item_editor)
   })
 ]);
 
 // src/schema/widgets/progressBar.ts
-import { z as z95 } from "zod";
-var ProgressBar = z95.looseObject({
-  type: z95.literal(WidgetType.ui_extension_progress_bar).default(WidgetType.ui_extension_progress_bar)
+import { z as z98 } from "zod";
+var ProgressBar = z98.looseObject({
+  type: z98.literal(WidgetType.ui_extension_progress_bar).default(WidgetType.ui_extension_progress_bar)
 });
 
 // src/schema/widgets/rebuyButton.ts
-import { z as z96 } from "zod";
-var RebuyButtonV1 = z96.looseObject({
-  type: z96.literal(WidgetType.ui_extension_button).default(WidgetType.ui_extension_button),
-  version: z96.literal(1)
+import { z as z99 } from "zod";
+var RebuyButtonV1 = z99.looseObject({
+  type: z99.literal(WidgetType.ui_extension_button).default(WidgetType.ui_extension_button),
+  version: z99.literal(1)
 });
-var RebuyButton = z96.discriminatedUnion("version", [
+var RebuyButton = z99.discriminatedUnion("version", [
   RebuyButtonV1,
   CABRootSection.extend({
-    type: z96.literal(WidgetType.ui_extension_button).default(WidgetType.ui_extension_button)
+    type: z99.literal(WidgetType.ui_extension_button).default(WidgetType.ui_extension_button)
   })
 ]);
 
 // src/schema/widgets/rebuyMonetize.ts
-import { z as z97 } from "zod";
-var RebuyMonetize = z97.looseObject({
-  type: z97.literal(WidgetType.ui_extension_ad).default(WidgetType.ui_extension_ad)
+import { z as z100 } from "zod";
+var RebuyMonetize = z100.looseObject({
+  type: z100.literal(WidgetType.ui_extension_ad).default(WidgetType.ui_extension_ad)
 });
-var RebuyMonetizeV1 = z97.object({
-  name: z97.string().nullable().optional(),
-  previewMode: z97.boolean().optional(),
+var RebuyMonetizeV1 = z100.object({
+  name: z100.string().nullable().optional(),
+  previewMode: z100.boolean().optional(),
   /** Privacy Policy footer href → the marker section's `privacyPolicyUrl`. */
-  privacyPolicyUrl: z97.string().nullable().optional(),
+  privacyPolicyUrl: z100.string().nullable().optional(),
   /** Ads-taxonomy sub-vertical id — one of the admin Monetize editor's two configurables. */
-  subVertical: z97.string().nullable().optional(),
-  tracking: z97.object({
-    enableAttribution: z97.boolean().optional(),
-    enableSource: z97.boolean().optional(),
-    enableWidget: z97.boolean().optional()
+  subVertical: z100.string().nullable().optional(),
+  tracking: z100.object({
+    enableAttribution: z100.boolean().optional(),
+    enableSource: z100.boolean().optional(),
+    enableWidget: z100.boolean().optional()
   }).optional(),
-  type: z97.literal(WidgetType.ui_extension_ad).default(WidgetType.ui_extension_ad),
-  version: z97.literal(1),
+  type: z100.literal(WidgetType.ui_extension_ad).default(WidgetType.ui_extension_ad),
+  version: z100.literal(1),
   /** Ads-taxonomy vertical id — one of the admin Monetize editor's two configurables. */
-  vertical: z97.string().nullable().optional()
+  vertical: z100.string().nullable().optional()
 });
 
 // src/schema/widgetData.ts
@@ -4619,7 +4723,7 @@ var extensionWidgetTypes = [
   WidgetType.ui_extension_line_item_editor,
   WidgetType.ui_extension_progress_bar
 ];
-var WidgetData = z98.discriminatedUnion("type", [
+var WidgetData = z101.discriminatedUnion("type", [
   ABTestingPlaceholder,
   CheckoutExtension,
   ContentBlock,
@@ -4979,36 +5083,36 @@ var SWITCH_LABELS = {
 };
 
 // src/schema/widgets/post-purchase-offer/postPurchaseOffer.ts
-import { z as z100 } from "zod";
+import { z as z103 } from "zod";
 
 // src/schema/widgets/post-purchase-offer/postPurchaseWidget.ts
-import { z as z99 } from "zod";
-var PostPurchaseWidgetLinkedFlow = z99.object({
-  id: z99.number(),
-  name: z99.string()
-});
-var PostPurchaseWidget = z99.object({
-  classification: z99.literal("post_purchase_offer_page").default("post_purchase_offer_page"),
-  createdAtTime: z99.iso.datetime({ offset: true }).optional(),
-  customEndpointName: z99.string().nullish(),
-  id: z99.number().default(0),
-  lastViewed: z99.iso.datetime({ offset: true }).nullish(),
-  linkedCustomEndpointId: z99.number().nullish(),
-  linkedFlows: z99.array(PostPurchaseWidgetLinkedFlow).optional(),
-  name: z99.string().default(""),
-  owner: z99.number().nullish(),
+import { z as z102 } from "zod";
+var PostPurchaseWidgetLinkedFlow = z102.object({
+  id: z102.number(),
+  name: z102.string()
+});
+var PostPurchaseWidget = z102.object({
+  classification: z102.literal("post_purchase_offer_page").default("post_purchase_offer_page"),
+  createdAtTime: z102.iso.datetime({ offset: true }).optional(),
+  customEndpointName: z102.string().nullish(),
+  id: z102.number().default(0),
+  lastViewed: z102.iso.datetime({ offset: true }).nullish(),
+  linkedCustomEndpointId: z102.number().nullish(),
+  linkedFlows: z102.array(PostPurchaseWidgetLinkedFlow).optional(),
+  name: z102.string().default(""),
+  owner: z102.number().nullish(),
   settings: PostPurchaseSettings
 });
 
 // src/schema/widgets/post-purchase-offer/postPurchaseOffer.ts
-var PostPurchaseOffer = z100.discriminatedUnion("successful", [
-  z100.strictObject({
-    errors: z100.array(z100.object({ message: z100.string() })),
-    message: z100.string(),
-    successful: z100.literal(false)
+var PostPurchaseOffer = z103.discriminatedUnion("successful", [
+  z103.strictObject({
+    errors: z103.array(z103.object({ message: z103.string() })),
+    message: z103.string(),
+    successful: z103.literal(false)
   }),
-  z100.strictObject({
-    successful: z100.literal(true),
+  z103.strictObject({
+    successful: z103.literal(true),
     widget: PostPurchaseWidget
   })
 ]);
@@ -5511,21 +5615,26 @@ var buildOfferTemplate = ({ location: location2, name } = {}) => CABRootSection.
   type: SHOPIFY_CHECKOUT_EXTENSION
 });
 
-// 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_TOKENS = ["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 marks = [{ attrs: { color: "base", fontSize }, type: "textStyle" }];
-  if (style?.textEmphasis === "bold") marks.push({ type: "bold" });
-  if (style?.textEmphasis === "italic") marks.push({ type: "italic" });
-  return { content: [{ content: [{ marks, 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: [
@@ -5551,6 +5660,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_TOKENS = ["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_TOKENS),
+    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 marks = [{ attrs: { color: "base", fontSize }, type: "textStyle" }];
+  if (style?.textEmphasis === "bold") marks.push({ type: "bold" });
+  if (style?.textEmphasis === "italic") marks.push({ type: "italic" });
+  return { content: [{ content: [{ marks, 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;
@@ -5592,29 +5759,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" },
@@ -5643,18 +5792,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 }
         }
@@ -5670,7 +5808,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" }
@@ -5684,10 +5822,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] },
@@ -5712,43 +5850,20 @@ var buildQuantityErrors = (quantity2) => {
 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_TOKENS),
-    sectionType: "text"
-  });
+  const errors = buildQuantityErrors(quantity2);
   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: quantity2.type ? QUANTITY_INPUT_TYPE[quantity2.type] : void 0,
+      maxValue: quantity2.maxValue,
+      minValue: quantity2.minValue
+    })
   ];
 };
+var buildSubscriptionButton = (settings) => subscriptionToggle(settings.productType, {
+  oneTime: settings.language?.cartSwitchToOnetime,
+  upgrade: settings.language?.upgradeToSubscription
+});
 var BUTTON_KINDS = ["plain", "primary", "secondary"];
 var buttonKind = (settings) => {
   const kind = settings.button?.kind;
@@ -5794,7 +5909,7 @@ 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);
@@ -6096,7 +6211,7 @@ var convertOfferToV2 = ({ id, name, settings }) => {
 
 // src/pricing/postPurchaseChangeset.ts
 var postPurchaseChangeset = (prepared) => {
-  const { selection: selection2, terms } = prepared;
+  const { selection: selection3, terms } = prepared;
   const subscription = readPostPurchaseSubscription(prepared);
   const { discount, shipping } = terms;
   const changesetDiscount = discount.type === "none" ? void 0 : {
@@ -6111,21 +6226,21 @@ var postPurchaseChangeset = (prepared) => {
         {
           ...changesetDiscount ? { discount: changesetDiscount } : {},
           initialShippingPrice,
-          quantity: selection2.quantity,
+          quantity: selection3.quantity,
           recurringShippingPrice,
           sellingPlanId: subscription.selection.sellingPlanId,
           shippingOption,
           type: "add_subscription",
-          variantId: selection2.variantId
+          variantId: selection3.variantId
         }
       ]
     });
   }
   const changes = [
     {
-      quantity: selection2.quantity,
+      quantity: selection3.quantity,
       type: "add_variant",
-      variantId: selection2.variantId,
+      variantId: selection3.variantId,
       ...changesetDiscount && changesetDiscount.value > 0 ? { discount: changesetDiscount } : {}
     }
   ];
@@ -6207,29 +6322,87 @@ var postPurchaseCosts = (prepared, response, currencyCode) => {
   });
 };
 
+// src/pricing/postPurchaseReduction.ts
+var reducePostPurchaseMinor = (priceMinor, { amount: amount2, type }, decimals) => {
+  if (type === "price") return amountToCents2(amount2, decimals);
+  const reduction = type === "percentage" ? Math.round(priceMinor * (amount2 / 100)) : type === "fixed_amount" ? amountToCents2(amount2, decimals) : 0;
+  return Math.max(0, priceMinor - reduction);
+};
+
+// src/pricing/postPurchaseDisplayFacts.ts
+var wholePercent = (savingMinor, struckMinor) => {
+  const percent = savingMinor / struckMinor * 100;
+  return Math.round(percent.toString().length > 5 ? Number(percent.toFixed(2)) : percent);
+};
+var postPurchaseDisplayPricing = ({
+  compareAtPrice,
+  currencyCode,
+  discount,
+  discountedFrom,
+  plan,
+  price
+}) => {
+  const decimals = currencyDecimals(currencyCode);
+  const regularMinor = amountToCents2(price, decimals);
+  const compareAtMinor = amountToCents2(compareAtPrice, decimals);
+  const fromCompareAt = discountedFrom === "compare_at_price" || discount.type === "none" && !plan;
+  const comparisonMinor = fromCompareAt && compareAtMinor > regularMinor ? compareAtMinor : regularMinor;
+  const planMinor = plan ? reducePostPurchaseMinor(regularMinor, plan, decimals) : regularMinor;
+  const priceMinor = reducePostPurchaseMinor(planMinor, discount, decimals);
+  const savingMinor = Math.max(0, comparisonMinor - priceMinor);
+  return {
+    comparisonMinor,
+    priceMinor,
+    savingMinor,
+    savingPercent: savingMinor && wholePercent(savingMinor, comparisonMinor)
+  };
+};
+var postPurchaseDisplayFacts = (input) => {
+  const { comparisonMinor, priceMinor, savingMinor, savingPercent } = postPurchaseDisplayPricing(input);
+  const percentPlan = input.plan?.type === "fixed_amount" || input.plan?.type === "price";
+  return {
+    currencyCode: input.currencyCode,
+    savingFormat: !percentPlan && input.discount.type === "fixed_amount" ? "amount" : "percent",
+    savingMinor,
+    savingPercent,
+    variantCompareAtPriceMinor: savingMinor > 0 ? comparisonMinor : null,
+    variantPriceMinor: priceMinor
+  };
+};
+
 // src/pricing/postPurchaseSubscriptionDisplay.ts
 var postPurchaseSubscriptionDisplay = (prepared, currencyCode) => {
   const subscription = readPostPurchaseSubscription(prepared);
   if (!subscription) return void 0;
-  const decimals = currencyDecimals(currencyCode);
-  const variant2 = subscription.product.variant;
-  const regular = amountToCents2(variant2.price, decimals);
-  const compareAt = amountToCents2(variant2.compareAtPrice, decimals);
-  const comparisonMinor = subscription.display.discountedFrom === "compare_at_price" && compareAt > regular ? compareAt : regular;
-  const adjustment = subscription.terms.subscription.adjustment;
-  const reduce = (price, discount) => {
-    const reduction = discount.type === "percentage" ? Math.round(price * discount.amount / 100) : discount.type === "fixed_amount" ? amountToCents2(discount.amount, decimals) : 0;
-    return Math.max(0, price - reduction);
-  };
-  const planPrice = adjustment?.type === "price" ? amountToCents2(adjustment.amount, decimals) : adjustment ? reduce(regular, { amount: adjustment.amount, type: adjustment.type }) : regular;
-  const priceMinor = reduce(planPrice, subscription.terms.discount);
-  const savingMinor = Math.max(0, comparisonMinor - priceMinor);
+  const { compareAtPrice, price } = subscription.product.variant;
   return PostPurchaseSubscriptionDisplay.parse({
-    comparisonMinor,
+    ...postPurchaseDisplayPricing({
+      compareAtPrice,
+      currencyCode,
+      discount: subscription.terms.discount,
+      discountedFrom: subscription.display.discountedFrom,
+      plan: subscription.terms.subscription.adjustment,
+      price
+    }),
+    currencyCode
+  });
+};
+
+// src/pricing/postPurchaseDisplayPrice.ts
+var postPurchaseDisplayPrice = (prepared, currencyCode) => {
+  const subscription = readPostPurchaseSubscription(prepared);
+  const { compareAtPrice, price } = prepared.product.variant;
+  const facts = postPurchaseDisplayFacts({
+    compareAtPrice,
     currencyCode,
-    priceMinor,
-    savingMinor,
-    savingPercent: comparisonMinor ? Math.round(savingMinor / comparisonMinor * 100) : 0
+    discount: prepared.terms.discount,
+    discountedFrom: prepared.display.discountedFrom,
+    plan: subscription?.terms.subscription.adjustment,
+    price
+  });
+  return PostPurchaseDisplayPrice.parse({
+    ...facts,
+    ...subscription && { subscriptionUnit: postPurchaseSubscriptionDisplay(subscription, currencyCode) }
   });
 };
 export {
@@ -6269,6 +6442,7 @@ export {
   CABExperiment,
   CABImageSection,
   CABImageSectionFields,
+  CABImageThumbnails,
   CABIntegrations,
   CABLayoutSection,
   CABLayoutWrapping,
@@ -6396,6 +6570,7 @@ export {
   PostPurchaseCollectionChoice,
   PostPurchaseCommonReviewRating,
   PostPurchaseDiscount,
+  PostPurchaseDisplayPrice,
   PostPurchaseExcludedProductIds,
   PostPurchaseGroupCatalog,
   PostPurchaseGroupChoice,
@@ -6467,6 +6642,7 @@ export {
   ProgressTierExclusionType,
   ProgressTierType,
   ProgressTierUnit,
+  PurchaseAdmissionModeSchema,
   PurchaseAnalyticsRequestSchema,
   PurchaseAnalyticsResponseSchema,
   PurchaseAnalyticsStatusSchema,
@@ -6543,11 +6719,17 @@ export {
   TiptapParagraph,
   TiptapText,
   UI_LABELS,
+  UpgradeCompensationProgressSchema,
+  UpgradeProgressSchema,
+  UpgradeRefundProgressSchema,
+  UpgradeReviewProgressSchema,
+  UpgradeReviewReasonSchema,
   UserConfig,
   VariableEffect,
   VariableType,
   VariantMode,
   VariantSelector,
+  VariantsMode,
   VerticalAlignment,
   WidgetData,
   WidgetType,
@@ -6626,6 +6808,7 @@ export {
   popoverPositions,
   postPurchaseChangeset,
   postPurchaseCosts,
+  postPurchaseDisplayPrice,
   postPurchaseHealthTaskId,
   postPurchaseSubscriptionDisplay,
   postPurchaseTaskNameSchema,
@@ -6664,6 +6847,7 @@ export {
   variantModes,
   variantPriceObject,
   variantSelectors,
+  variantsModes,
   verticalAlignments,
   widgetTypes
 };