@rebuy/rebuy 3.39.1 → 3.40.0

package/dist/index.cjs

@@ -125,8 +125,20 @@ __export(src_exports, {
   GridItem: () => GridItem,
   HEX_COLOR_REGEX: () => HEX_COLOR_REGEX,
   HTML_TAGS_REGEX: () => HTML_TAGS_REGEX,
+  HealthAttemptSchema: () => HealthAttemptSchema,
+  HealthClaimRequestSchema: () => HealthClaimRequestSchema,
+  HealthClaimResponseSchema: () => HealthClaimResponseSchema,
+  HealthFactSchema: () => HealthFactSchema,
+  HealthPrepareRequestSchema: () => HealthPrepareRequestSchema,
+  HealthPrepareResponseSchema: () => HealthPrepareResponseSchema,
+  HealthResultRequestSchema: () => HealthResultRequestSchema,
+  HealthResultResponseSchema: () => HealthResultResponseSchema,
+  HealthResultSchema: () => HealthResultSchema,
+  HealthScheduleAcknowledgementSchema: () => HealthScheduleAcknowledgementSchema,
+  HealthScheduleReceiptSchema: () => HealthScheduleReceiptSchema,
   HealthScheduleSchema: () => HealthScheduleSchema,
   HealthSchedulingResponseSchema: () => HealthSchedulingResponseSchema,
+  HealthStateSchema: () => HealthStateSchema,
   HoldSettingSchema: () => HoldSettingSchema,
   HorizontalAlignment: () => HorizontalAlignment,
   IconName: () => IconName,
@@ -161,6 +173,7 @@ __export(src_exports, {
   OrderDecisionSchema: () => OrderDecisionSchema,
   POST_PURCHASE_SKIP_LIMIT: () => POST_PURCHASE_SKIP_LIMIT,
   PayButtonBlock: () => PayButtonBlock,
+  PendingReleaseAuthoritySchema: () => PendingReleaseAuthoritySchema,
   PopoverPosition: () => PopoverPosition,
   PostPurchaseAmount: () => PostPurchaseAmount,
   PostPurchaseAppIdSchema: () => PostPurchaseAppIdSchema,
@@ -175,6 +188,7 @@ __export(src_exports, {
   PostPurchaseGroupChoice: () => PostPurchaseGroupChoice,
   PostPurchaseGroupDescription: () => PostPurchaseGroupDescription,
   PostPurchaseGroupSelection: () => PostPurchaseGroupSelection,
+  PostPurchaseHealthTaskNameSchema: () => PostPurchaseHealthTaskNameSchema,
   PostPurchaseKlaviyoReviewRating: () => PostPurchaseKlaviyoReviewRating,
   PostPurchaseMemberIdentity: () => PostPurchaseMemberIdentity,
   PostPurchaseMemberPointer: () => PostPurchaseMemberPointer,
@@ -210,6 +224,7 @@ __export(src_exports, {
   PostPurchaseQuantityPolicy: () => PostPurchaseQuantityPolicy,
   PostPurchaseReviewCount: () => PostPurchaseReviewCount,
   PostPurchaseReviewStyles: () => PostPurchaseReviewStyles,
+  PostPurchaseSessionIdSchema: () => PostPurchaseSessionIdSchema,
   PostPurchaseSettings: () => PostPurchaseSettings,
   PostPurchaseShadowReportFields: () => PostPurchaseShadowReportFields,
   PostPurchaseShadowReportSchema: () => PostPurchaseShadowReportSchema,
@@ -254,6 +269,7 @@ __export(src_exports, {
   QuantityInput: () => QuantityInput,
   REVIEW_LABELS: () => REVIEW_LABELS,
   ROOT_RELATIVE_PATH_REGEX: () => ROOT_RELATIVE_PATH_REGEX,
+  ReadyReleaseAuthoritySchema: () => ReadyReleaseAuthoritySchema,
   ReadySessionTimingSchema: () => ReadySessionTimingSchema,
   RebuyButton: () => RebuyButton,
   RebuyButtonV1: () => RebuyButtonV1,
@@ -262,6 +278,11 @@ __export(src_exports, {
   RebuyMonetizeV1: () => RebuyMonetizeV1,
   RecordedOfferDeclineSchema: () => RecordedOfferDeclineSchema,
   RecordedPurchaseObservationSchema: () => RecordedPurchaseObservationSchema,
+  ReleaseAuthorityRequestSchema: () => ReleaseAuthorityRequestSchema,
+  ReleaseAuthorityResponseSchema: () => ReleaseAuthorityResponseSchema,
+  ReleaseClaimRequestSchema: () => ReleaseClaimRequestSchema,
+  ReleaseClaimResponseSchema: () => ReleaseClaimResponseSchema,
+  ReleaseOwnerSchema: () => ReleaseOwnerSchema,
   RequiredHealthSchema: () => RequiredHealthSchema,
   ResultCountOperator: () => ResultCountOperator,
   ResultTagOperator: () => ResultTagOperator,
@@ -286,6 +307,8 @@ __export(src_exports, {
   SessionIdentitySchema: () => SessionIdentitySchema,
   SessionOrderTimingSchema: () => SessionOrderTimingSchema,
   SessionPolicySchema: () => SessionPolicySchema,
+  SessionReleaseScheduleRequestSchema: () => SessionReleaseScheduleRequestSchema,
+  SessionReleaseScheduleResponseSchema: () => SessionReleaseScheduleResponseSchema,
   SessionStartRequestSchema: () => SessionStartRequestSchema,
   SessionStartResponseSchema: () => SessionStartResponseSchema,
   ShopConfig: () => ShopConfig,
@@ -390,7 +413,9 @@ __export(src_exports, {
   popoverPositions: () => popoverPositions,
   postPurchaseChangeset: () => postPurchaseChangeset,
   postPurchaseCosts: () => postPurchaseCosts,
+  postPurchaseHealthTaskId: () => postPurchaseHealthTaskId,
   postPurchaseSubscriptionDisplay: () => postPurchaseSubscriptionDisplay,
+  postPurchaseTaskNameSchema: () => postPurchaseTaskNameSchema,
   productImageObject: () => productImageObject,
   productTypes: () => productTypes,
   progressTierExclusionTypes: () => progressTierExclusionTypes,
@@ -3085,42 +3110,68 @@ var ExitPolicySchema = import_zod36.z.discriminatedUnion("status", [
 ]);
 
 // src/schema/postPurchaseFinish.ts
-var import_zod41 = require("zod");
+var import_zod42 = require("zod");
 
 // src/schema/postPurchaseFollowups.ts
-var import_zod39 = require("zod");
+var import_zod40 = require("zod");
 
 // src/schema/postPurchaseHealthProgress.ts
+var import_zod38 = require("zod");
+
+// src/schema/postPurchaseReleaseAuthority.ts
 var import_zod37 = require("zod");
-var HealthScheduleSchema = import_zod37.z.strictObject({
+var PostPurchaseSessionIdSchema = import_zod37.z.string().regex(/^[a-f0-9]{64}$/);
+var ReleaseOwnerSchema = import_zod37.z.enum(["rebuy", "shopify"]);
+var ReleaseAuthorityRequestSchema = import_zod37.z.strictObject({
+  orderId: PostPurchaseOrderIdSchema,
+  shop: ShopifyDomainSchema
+});
+var ReadyReleaseAuthoritySchema = import_zod37.z.object({
+  deadline: PostPurchaseTimestampSchema,
+  releaseOwner: ReleaseOwnerSchema,
+  sessionId: PostPurchaseSessionIdSchema,
+  status: import_zod37.z.literal("ready")
+});
+var PendingReleaseAuthoritySchema = import_zod37.z.object({ status: import_zod37.z.literal("pending") });
+var ReleaseAuthorityResponseSchema = import_zod37.z.object({
+  data: import_zod37.z.discriminatedUnion("status", [
+    import_zod37.z.object({ status: import_zod37.z.literal("unknown") }),
+    PendingReleaseAuthoritySchema,
+    ReadyReleaseAuthoritySchema
+  ]),
+  successful: import_zod37.z.literal(true)
+});
+
+// src/schema/postPurchaseHealthProgress.ts
+var HealthScheduleSchema = import_zod38.z.strictObject({
   checkoutToken: DecideRequestSchema.shape.checkoutToken,
   healthScheduledAt: PostPurchaseTimestampSchema,
-  operationId: PurchaseReceiptSchema.shape.operationId,
+  operationId: PurchaseReceiptSchema.shape.operationId.regex(/^[a-f0-9-]{36}$/),
   orderId: PostPurchaseOrderIdSchema,
-  removePartialOrder: import_zod37.z.boolean(),
-  sessionId: import_zod37.z.string().regex(/^[a-f0-9]{64}$/),
+  removePartialOrder: import_zod38.z.boolean(),
+  sessionId: PostPurchaseSessionIdSchema,
   shop: DecideRequestSchema.shape.shop
 });
-var HealthSchedulingResponseSchema = import_zod37.z.object({
-  data: import_zod37.z.object({
-    callbackStatus: import_zod37.z.enum(["pending", "attempted", "returned", "unknown"]),
+var HealthSchedulingResponseSchema = import_zod38.z.object({
+  data: import_zod38.z.object({
+    callbackStatus: import_zod38.z.enum(["pending", "attempted", "returned", "unknown"]),
     facts: HealthScheduleSchema,
-    scheduling: import_zod37.z.union([
-      import_zod37.z.strictObject({ recordedAt: PostPurchaseTimestampSchema, status: import_zod37.z.literal("verified") }),
-      import_zod37.z.strictObject({ status: import_zod37.z.enum(["unavailable", "unverified"]) })
+    scheduling: import_zod38.z.union([
+      import_zod38.z.strictObject({ recordedAt: PostPurchaseTimestampSchema, status: import_zod38.z.literal("verified") }),
+      import_zod38.z.strictObject({ status: import_zod38.z.enum(["unavailable", "unverified"]) })
     ])
   }),
-  successful: import_zod37.z.literal(true)
+  successful: import_zod38.z.literal(true)
 });
 
 // src/schema/postPurchaseObservation.ts
-var import_zod38 = require("zod");
-var PurchaseObservationSchema = import_zod38.z.union([
-  import_zod38.z.object({
-    changesetApplicationsRemaining: import_zod38.z.number().int().nonnegative(),
-    errors: import_zod38.z.array(
-      import_zod38.z.object({
-        code: import_zod38.z.enum([
+var import_zod39 = require("zod");
+var PurchaseObservationSchema = import_zod39.z.union([
+  import_zod39.z.object({
+    changesetApplicationsRemaining: import_zod39.z.number().int().nonnegative(),
+    errors: import_zod39.z.array(
+      import_zod39.z.object({
+        code: import_zod39.z.enum([
           "payment_required",
           "insufficient_inventory",
           "changeset_already_applied",
@@ -3134,83 +3185,83 @@ var PurchaseObservationSchema = import_zod38.z.union([
           "subscription_limit_error",
           "order_released_error"
         ]),
-        message: import_zod38.z.string()
+        message: import_zod39.z.string()
       }).strict()
     ),
-    status: import_zod38.z.enum(["processed", "partially_processed", "unprocessed"])
+    status: import_zod39.z.enum(["processed", "partially_processed", "unprocessed"])
   }).strict(),
-  import_zod38.z.object({ reason: import_zod38.z.literal("application-error"), status: import_zod38.z.literal("unknown") }).strict()
+  import_zod39.z.object({ reason: import_zod39.z.literal("application-error"), status: import_zod39.z.literal("unknown") }).strict()
 ]);
-var RecordedPurchaseObservationSchema = import_zod38.z.object({
+var RecordedPurchaseObservationSchema = import_zod39.z.object({
   observation: PurchaseObservationSchema,
   recordedAt: PostPurchaseTimestampSchema
 }).strict();
 var PurchaseObservationRequestSchema = DecideRequestSchema.extend({
   observation: PurchaseObservationSchema,
-  operationId: import_zod38.z.uuid()
+  operationId: import_zod39.z.uuid()
 }).strict();
-var PurchaseObservationResponseSchema = import_zod38.z.object({
-  data: RecordedPurchaseObservationSchema.extend({ operationId: import_zod38.z.uuid() }),
-  successful: import_zod38.z.literal(true)
+var PurchaseObservationResponseSchema = import_zod39.z.object({
+  data: RecordedPurchaseObservationSchema.extend({ operationId: import_zod39.z.uuid() }),
+  successful: import_zod39.z.literal(true)
 });
 
 // src/schema/postPurchaseFollowups.ts
-var RequiredHealthSchema = import_zod39.z.union([
+var RequiredHealthSchema = import_zod40.z.union([
   HealthSchedulingResponseSchema.shape.data,
-  import_zod39.z.strictObject({ status: import_zod39.z.literal("unavailable") })
+  import_zod40.z.strictObject({ status: import_zod40.z.literal("unavailable") })
 ]);
-var AcceptedFollowupsResponseSchema = import_zod39.z.object({
-  data: import_zod39.z.object({
-    acceptedEvent: import_zod39.z.union([
+var AcceptedFollowupsResponseSchema = import_zod40.z.object({
+  data: import_zod40.z.object({
+    acceptedEvent: import_zod40.z.union([
       AcceptedEventResponseSchema.shape.data,
-      import_zod39.z.strictObject({ status: import_zod39.z.literal("unavailable") })
+      import_zod40.z.strictObject({ status: import_zod40.z.literal("unavailable") })
     ]),
     acceptedMetafield: AcceptedMetafieldResultSchema,
     health: RequiredHealthSchema,
     purchase: PurchaseObservationResponseSchema.shape.data
   }),
-  successful: import_zod39.z.literal(true)
+  successful: import_zod40.z.literal(true)
 });
 
 // src/schema/postPurchaseSessionClose.ts
-var import_zod40 = require("zod");
-var SessionClosureSchema = import_zod40.z.object({ closedAt: PostPurchaseTimestampSchema, status: import_zod40.z.literal("closed") });
+var import_zod41 = require("zod");
+var SessionClosureSchema = import_zod41.z.object({ closedAt: PostPurchaseTimestampSchema, status: import_zod41.z.literal("closed") });
 var SessionCloseRequestSchema = DecideRequestSchema.strict();
-var SessionCloseResponseSchema = import_zod40.z.object({ data: SessionClosureSchema, successful: import_zod40.z.literal(true) });
+var SessionCloseResponseSchema = import_zod41.z.object({ data: SessionClosureSchema, successful: import_zod41.z.literal(true) });
 
 // src/schema/postPurchaseFinish.ts
-var FinishedPurchaseSchema = import_zod41.z.union([
-  import_zod41.z.strictObject({ status: import_zod41.z.literal("none") }),
-  import_zod41.z.strictObject({
+var FinishedPurchaseSchema = import_zod42.z.union([
+  import_zod42.z.strictObject({ status: import_zod42.z.literal("none") }),
+  import_zod42.z.strictObject({
     operationId: PurchaseReceiptSchema.shape.operationId,
-    status: import_zod41.z.union([
-      import_zod41.z.literal("pending"),
+    status: import_zod42.z.union([
+      import_zod42.z.literal("pending"),
       ...PurchaseObservationSchema.options.map((option) => option.shape.status)
     ])
   })
 ]);
 var SessionFinishRequestSchema = DecideRequestSchema.strict();
-var SessionFinishResponseSchema = import_zod41.z.object({
+var SessionFinishResponseSchema = import_zod42.z.object({
   data: SessionClosureSchema.extend({
     classification: ClassificationProgressSchema,
     exitPolicy: ExitPolicySchema,
     health: RequiredHealthSchema.nullable(),
     purchase: FinishedPurchaseSchema
   }),
-  successful: import_zod41.z.literal(true)
+  successful: import_zod42.z.literal(true)
 });
 
 // src/schema/postPurchaseQuantity.ts
-var import_zod64 = require("zod");
+var import_zod65 = require("zod");
 
 // src/schema/postPurchaseProductCollectionView.ts
-var import_zod63 = require("zod");
+var import_zod64 = require("zod");
 
 // src/schema/postPurchaseProductView.ts
-var import_zod62 = require("zod");
+var import_zod63 = require("zod");
 
 // src/schema/postPurchaseGroupCatalog.ts
-var import_zod42 = require("zod");
+var import_zod43 = require("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({
@@ -3218,17 +3269,17 @@ var PostPurchaseGroupDescription = source.pick({ description: true, id: true, im
   image: source.shape.image.default(null),
   options: PostPurchaseVariantCatalog.shape.options.default([])
 });
-var PostPurchaseGroupCatalog = import_zod42.z.object({
+var PostPurchaseGroupCatalog = import_zod43.z.object({
   memberProductId: productId,
-  options: import_zod42.z.array(import_zod42.z.object({ productId, title: import_zod42.z.string(), variantCatalog: PostPurchaseVariantCatalog }))
+  options: import_zod43.z.array(import_zod43.z.object({ productId, title: import_zod43.z.string(), variantCatalog: PostPurchaseVariantCatalog }))
 });
-var PostPurchaseGroupSelection = import_zod42.z.object({
+var PostPurchaseGroupSelection = import_zod43.z.object({
   memberProductId: productId,
   productId
 });
 
 // src/schema/widgets/checkout-and-beyond/root.ts
-var import_zod61 = require("zod");
+var import_zod62 = require("zod");
 
 // src/schema/widgets/checkout-and-beyond/constants.ts
 var import_es_toolkit3 = require("es-toolkit");
@@ -3283,18 +3334,18 @@ var targetAreas = {
 
 // src/schema/widgets/checkout-and-beyond/layout.ts
 var import_uuid15 = require("uuid");
-var import_zod60 = require("zod");
+var import_zod61 = require("zod");
 
 // src/schema/widgets/checkout-and-beyond/shared.ts
-var import_zod59 = require("zod");
+var import_zod60 = require("zod");
 
 // src/schema/widgets/checkout-and-beyond/banner.ts
-var import_zod43 = require("zod");
-var CABBannerSection = import_zod43.z.lazy(
+var import_zod44 = require("zod");
+var CABBannerSection = import_zod44.z.lazy(
   () => CABLayoutSection.omit({ sectionType: true }).extend({
-    buttonField: import_zod43.z.enum(buttonFields).optional(),
-    color: import_zod43.z.enum(bannerColors).default("info"),
-    dismissible: import_zod43.z.boolean().default(true),
+    buttonField: import_zod44.z.enum(buttonFields).optional(),
+    color: import_zod44.z.enum(bannerColors).default("info"),
+    dismissible: import_zod44.z.boolean().default(true),
     /**
      * The `s-banner` heading — localized content (a buyer can see a merchant-composed banner). Absent OR
      * blank ⇒ no heading; the renderer emits no heading slot for `''` rather than an empty one.
@@ -3310,18 +3361,18 @@ var CABBannerSection = import_zod43.z.lazy(
      * not a 500. Nothing emits `heading` yet; the first converter that maps merchant banner copy into it
      * either strips first or teaches `normalizeTextContent` to strip this field.
      */
-    heading: import_zod43.z.record(import_zod43.z.string(), import_zod43.z.string().refine(checkForHTML, NO_HTML)).optional(),
-    sectionType: import_zod43.z.literal(SectionType.banner).default(SectionType.banner)
+    heading: import_zod44.z.record(import_zod44.z.string(), import_zod44.z.string().refine(checkForHTML, NO_HTML)).optional(),
+    sectionType: import_zod44.z.literal(SectionType.banner).default(SectionType.banner)
   })
 );
 
 // src/schema/widgets/checkout-and-beyond/button.ts
 var import_uuid5 = require("uuid");
-var import_zod45 = require("zod");
+var import_zod46 = require("zod");
 
 // src/schema/widgets/checkout-and-beyond/image.ts
 var import_uuid4 = require("uuid");
-var import_zod44 = require("zod");
+var import_zod45 = require("zod");
 
 // src/schema/widgets/checkout-and-beyond/icons.ts
 var iconNames = [
@@ -3408,17 +3459,17 @@ var iconTones = ["auto", "critical", "custom", "info", "neutral", "success", "wa
 var IconTone = freezeEnum(iconTones);
 
 // src/schema/widgets/checkout-and-beyond/image.ts
-var CABImageSectionFields = import_zod44.z.object({
+var CABImageSectionFields = import_zod45.z.object({
   ...CABVariableFields,
-  altText: import_zod44.z.string().refine(checkForHTML, NO_HTML).default(""),
+  altText: import_zod45.z.string().refine(checkForHTML, NO_HTML).default(""),
   /**
    * Image width÷height (e.g. `46` for the progress-bar fill); `null` renders at natural size. Any POSITIVE
    * ratio — never limited to 1, but never `0`/negative either: a renderer dividing by it would get `Infinity`,
    * and CSS `aspect-ratio` drops a negative value and silently reverts to natural size.
    */
-  aspectRatio: import_zod44.z.number().positive().nullable().default(null),
-  border: import_zod44.z.lazy(() => CABBorder),
-  buttonField: import_zod44.z.enum(buttonFields).optional(),
+  aspectRatio: import_zod45.z.number().positive().nullable().default(null),
+  border: import_zod45.z.lazy(() => CABBorder),
+  buttonField: import_zod45.z.enum(buttonFields).optional(),
   /**
    * `icon` renders `source` as a single `s-icon` by name (the uber-image path covers icons too), reading
    * `iconSize`/`iconTone`. The other values are a harmless informational holdover from the previous
@@ -3437,29 +3488,29 @@ var CABImageSectionFields = import_zod44.z.object({
    * behavior degraded gracefully and told us about it. The client-assembled half of the invariant was never
    * the risky half.
    */
-  category: import_zod44.z.enum(["gallery", "icon", "icons", "payment-methods", "secure-checkout"]).nullable().default(null),
+  category: import_zod45.z.enum(["gallery", "icon", "icons", "payment-methods", "secure-checkout"]).nullable().default(null),
   /** `icon`-mode only: the `s-icon` `size`; `null` ⇒ the component default (`base`). Ignored by image treatments. */
-  iconSize: import_zod44.z.enum(iconSizes).nullable().default(null),
+  iconSize: import_zod45.z.enum(iconSizes).nullable().default(null),
   /** `icon`-mode only: the `s-icon` `tone`; `null` ⇒ the component default (`auto`). Ignored by image treatments. */
-  iconTone: import_zod44.z.enum(iconTones).nullable().default(null),
-  name: import_zod44.z.string().optional(),
-  naturalHeight: import_zod44.z.number().default(0),
-  naturalWidth: import_zod44.z.number().default(0),
+  iconTone: import_zod45.z.enum(iconTones).nullable().default(null),
+  name: import_zod45.z.string().optional(),
+  naturalHeight: import_zod45.z.number().default(0),
+  naturalWidth: import_zod45.z.number().default(0),
   /**
    * `contain` (the component default): dimensionless images render in s-image's 1/1 default frame, and
    * `cover` would crop non-square art (payment badges lost their edges — 15993); `contain` letterboxes.
    */
-  objectFit: import_zod44.z.enum(objectFits).default(ObjectFit.contain),
-  sectionId: import_zod44.z.uuid().default(() => (0, import_uuid4.v7)()),
-  sectionType: import_zod44.z.literal(SectionType.image).default(SectionType.image),
+  objectFit: import_zod45.z.enum(objectFits).default(ObjectFit.contain),
+  sectionId: import_zod45.z.uuid().default(() => (0, import_uuid4.v7)()),
+  sectionType: import_zod45.z.literal(SectionType.image).default(SectionType.image),
   /**
    * An image URL or dynamic token, an empty default, or — when `category: 'icon'` — an icon NAME. Icon mode
    * takes a name or `''` only, NOT a token: no renderer resolves a token to an icon today, so accepting one
    * would promise a capability that doesn't exist. Widen the refine's carve-out to `DYNAMIC_TOKEN_REGEX` when a
    * server-chosen tier icon actually needs it.
    */
-  source: import_zod44.z.union([import_zod44.z.url(), import_zod44.z.literal(""), import_zod44.z.string().regex(DYNAMIC_TOKEN_REGEX), import_zod44.z.enum(iconNames)]).default(""),
-  width: import_zod44.z.number().default(100)
+  source: import_zod45.z.union([import_zod45.z.url(), import_zod45.z.literal(""), import_zod45.z.string().regex(DYNAMIC_TOKEN_REGEX), import_zod45.z.enum(iconNames)]).default(""),
+  width: import_zod45.z.number().default(100)
 });
 var iconNameSet = new Set(iconNames);
 var isIconName = (source2) => iconNameSet.has(source2);
@@ -3479,35 +3530,35 @@ var CABImageSection = CABImageSectionFields.superRefine(({ category, source: sou
 });
 
 // src/schema/widgets/checkout-and-beyond/button.ts
-var CABButtonContent = import_zod45.z.lazy(
-  () => import_zod45.z.discriminatedUnion("sectionType", [CABImageSection, CABLayoutSection, CABTextSection])
+var CABButtonContent = import_zod46.z.lazy(
+  () => import_zod46.z.discriminatedUnion("sectionType", [CABImageSection, CABLayoutSection, CABTextSection])
 );
-var CABButtonSection = import_zod45.z.object({
+var CABButtonSection = import_zod46.z.object({
   ...CABVariableFields,
-  action: import_zod45.z.union([import_zod45.z.literal(""), import_zod45.z.enum(buttonActions)]).default(""),
-  buttonStyle: import_zod45.z.enum(buttonStyles).default(ButtonStyle.primary),
-  custom: import_zod45.z.object({
-    color: import_zod45.z.string().regex(HEX_COLOR_REGEX).default("#005bd3"),
-    height: import_zod45.z.number().default(52),
-    width: import_zod45.z.number().default(300)
+  action: import_zod46.z.union([import_zod46.z.literal(""), import_zod46.z.enum(buttonActions)]).default(""),
+  buttonStyle: import_zod46.z.enum(buttonStyles).default(ButtonStyle.primary),
+  custom: import_zod46.z.object({
+    color: import_zod46.z.string().regex(HEX_COLOR_REGEX).default("#005bd3"),
+    height: import_zod46.z.number().default(52),
+    width: import_zod46.z.number().default(300)
   }).default({
     color: "#005bd3",
     height: 52,
     width: 300
   }),
-  disableDowngrade: import_zod45.z.boolean().default(false),
-  name: import_zod45.z.string().optional(),
-  optionId: import_zod45.z.number().optional(),
-  popover: import_zod45.z.object({
-    alignment: import_zod45.z.enum(textAlignments).default(TextAlignment.center),
-    position: import_zod45.z.enum(popoverPositions).default(PopoverPosition.blockStart)
+  disableDowngrade: import_zod46.z.boolean().default(false),
+  name: import_zod46.z.string().optional(),
+  optionId: import_zod46.z.number().optional(),
+  popover: import_zod46.z.object({
+    alignment: import_zod46.z.enum(textAlignments).default(TextAlignment.center),
+    position: import_zod46.z.enum(popoverPositions).default(PopoverPosition.blockStart)
   }).optional().default(() => ({
     alignment: TextAlignment.center,
     position: PopoverPosition.blockStart
   })),
-  sectionId: import_zod45.z.uuid().default(() => (0, import_uuid5.v7)()),
-  sections: import_zod45.z.union([import_zod45.z.array(CABButtonContent), import_zod45.z.strictObject({}).transform(() => [])]).default(() => []),
-  sectionType: import_zod45.z.literal(SectionType.button).default(SectionType.button),
+  sectionId: import_zod46.z.uuid().default(() => (0, import_uuid5.v7)()),
+  sections: import_zod46.z.union([import_zod46.z.array(CABButtonContent), import_zod46.z.strictObject({}).transform(() => [])]).default(() => []),
+  sectionType: import_zod46.z.literal(SectionType.button).default(SectionType.button),
   /**
    * The smart-cart tier this button acts on (`addGift`/`removeGift`): scopes the click to one tier's gift. The
    * client resolves the tier's gift (productId) from the progress-bar context by this `tierId` — the button node
@@ -3522,96 +3573,96 @@ var CABButtonSection = import_zod45.z.object({
    * lookup finds no tier and the click resolves to nothing. Safe to bound — the field is new, so there are no
    * stored payloads to grandfather, and the producer is client code, not a merchant form.
    */
-  tier: import_zod45.z.object({ tierId: import_zod45.z.string().min(1) }).optional(),
+  tier: import_zod46.z.object({ tierId: import_zod46.z.string().min(1) }).optional(),
   /** Fire-and-forget pixel POSTed when the button is clicked (e.g. a Monetize decline). */
-  trackingUrl: import_zod45.z.string().optional(),
+  trackingUrl: import_zod46.z.string().optional(),
   /**
    * Secondary effects applied to in-scope variables on click, alongside (never instead of) the primary
    * `action` — an `addToOrder` button can also flip a variable. Applied in array order.
    */
-  variableEffects: import_zod45.z.array(CABVariableEffect).optional()
+  variableEffects: import_zod46.z.array(CABVariableEffect).optional()
 });
 
 // src/schema/widgets/checkout-and-beyond/carousel.ts
-var import_zod50 = require("zod");
+var import_zod51 = require("zod");
 
 // src/schema/widgets/checkout-and-beyond/offers.ts
-var import_zod49 = require("zod");
+var import_zod50 = require("zod");
 
 // src/schema/widgets/checkout-and-beyond/dataSource.ts
 var import_uuid6 = require("uuid");
-var import_zod46 = require("zod");
-var CABDiscount = import_zod46.z.object({
-  amount: import_zod46.z.union([import_zod46.z.number(), import_zod46.z.string()]).catch(0),
-  discountedBy: import_zod46.z.string().optional(),
-  discountedFrom: import_zod46.z.enum(discountSources).optional().catch(void 0),
-  type: import_zod46.z.enum(discountTypes).catch("none")
-});
-var CABIntegrations = import_zod46.z.object({
-  judgeme: import_zod46.z.boolean().default(false),
-  junip: import_zod46.z.boolean().default(false),
-  klaviyo: import_zod46.z.boolean().default(false),
-  loox: import_zod46.z.boolean().default(false),
-  okendo: import_zod46.z.boolean().default(false),
-  opinew: import_zod46.z.boolean().default(false),
-  reviewsio: import_zod46.z.boolean().default(false),
-  stamped: import_zod46.z.boolean().default(false),
-  yotpo: import_zod46.z.boolean().default(false)
-});
-var CABVariantLabels = import_zod46.z.object({
-  variantOption: import_zod46.z.string().optional().catch(void 0),
-  variantOptions: import_zod46.z.string().optional().catch(void 0)
-});
-var CABDataSourceSection = import_zod46.z.object({
-  dataSourceId: import_zod46.z.number().nullable().default(null),
-  dataSourcePath: import_zod46.z.string().default(DEFAULT_ENDPOINTS[0].value),
+var import_zod47 = require("zod");
+var CABDiscount = import_zod47.z.object({
+  amount: import_zod47.z.union([import_zod47.z.number(), import_zod47.z.string()]).catch(0),
+  discountedBy: import_zod47.z.string().optional(),
+  discountedFrom: import_zod47.z.enum(discountSources).optional().catch(void 0),
+  type: import_zod47.z.enum(discountTypes).catch("none")
+});
+var CABIntegrations = import_zod47.z.object({
+  judgeme: import_zod47.z.boolean().default(false),
+  junip: import_zod47.z.boolean().default(false),
+  klaviyo: import_zod47.z.boolean().default(false),
+  loox: import_zod47.z.boolean().default(false),
+  okendo: import_zod47.z.boolean().default(false),
+  opinew: import_zod47.z.boolean().default(false),
+  reviewsio: import_zod47.z.boolean().default(false),
+  stamped: import_zod47.z.boolean().default(false),
+  yotpo: import_zod47.z.boolean().default(false)
+});
+var CABVariantLabels = import_zod47.z.object({
+  variantOption: import_zod47.z.string().optional().catch(void 0),
+  variantOptions: import_zod47.z.string().optional().catch(void 0)
+});
+var CABDataSourceSection = import_zod47.z.object({
+  dataSourceId: import_zod47.z.number().nullable().default(null),
+  dataSourcePath: import_zod47.z.string().default(DEFAULT_ENDPOINTS[0].value),
   discount: CABDiscount.optional(),
   integrations: CABIntegrations.optional(),
-  limit: import_zod46.z.number().default(1),
-  matchVariant: import_zod46.z.boolean().default(false),
-  matchVariantOutOfStock: import_zod46.z.boolean().default(false),
-  name: import_zod46.z.string().default(DEFAULT_ENDPOINTS[0].label),
-  productType: import_zod46.z.enum(productTypes).optional(),
-  sectionId: import_zod46.z.uuid().default(() => (0, import_uuid6.v7)()),
-  sectionType: import_zod46.z.literal(SectionType.dataSource).default(SectionType.dataSource),
+  limit: import_zod47.z.number().default(1),
+  matchVariant: import_zod47.z.boolean().default(false),
+  matchVariantOutOfStock: import_zod47.z.boolean().default(false),
+  name: import_zod47.z.string().default(DEFAULT_ENDPOINTS[0].label),
+  productType: import_zod47.z.enum(productTypes).optional(),
+  sectionId: import_zod47.z.uuid().default(() => (0, import_uuid6.v7)()),
+  sectionType: import_zod47.z.literal(SectionType.dataSource).default(SectionType.dataSource),
   /** Default subscribe-vs-one-time for `productType: both` (legacy `subscription_is_default`). */
-  subscriptionIsDefault: import_zod46.z.boolean().default(false),
-  treatAsGwp: import_zod46.z.boolean().default(false),
+  subscriptionIsDefault: import_zod47.z.boolean().default(false),
+  treatAsGwp: import_zod47.z.boolean().default(false),
   variantLabels: CABVariantLabels.optional().catch(void 0)
 });
 
 // src/schema/widgets/checkout-and-beyond/products.ts
 var import_uuid8 = require("uuid");
-var import_zod48 = require("zod");
+var import_zod49 = require("zod");
 
 // src/schema/widgets/checkout-and-beyond/product.ts
 var import_uuid7 = require("uuid");
-var import_zod47 = require("zod");
-var CABVariantContent = import_zod47.z.lazy(
-  () => import_zod47.z.discriminatedUnion("sectionType", [CABButtonSection, CABTextSection])
+var import_zod48 = require("zod");
+var CABVariantContent = import_zod48.z.lazy(
+  () => import_zod48.z.discriminatedUnion("sectionType", [CABButtonSection, CABTextSection])
 );
-var CABProductSection = import_zod47.z.object({
+var CABProductSection = import_zod48.z.object({
   ...CABVariableFields,
-  name: import_zod47.z.string().optional(),
-  productId: import_zod47.z.number().nullable().default(null),
-  sectionId: import_zod47.z.uuid().default(() => (0, import_uuid7.v7)()),
-  sections: import_zod47.z.union([import_zod47.z.array(CABVariantContent), import_zod47.z.strictObject({}).transform(() => [])]).default(() => []),
-  sectionType: import_zod47.z.literal(SectionType.product).default(SectionType.product),
-  selectors: import_zod47.z.record(import_zod47.z.string(), import_zod47.z.enum(variantSelectors).default(VariantSelector.menu)).default(() => ({})),
-  variantMode: import_zod47.z.enum(variantModes).default(VariantMode.multiple)
+  name: import_zod48.z.string().optional(),
+  productId: import_zod48.z.number().nullable().default(null),
+  sectionId: import_zod48.z.uuid().default(() => (0, import_uuid7.v7)()),
+  sections: import_zod48.z.union([import_zod48.z.array(CABVariantContent), import_zod48.z.strictObject({}).transform(() => [])]).default(() => []),
+  sectionType: import_zod48.z.literal(SectionType.product).default(SectionType.product),
+  selectors: import_zod48.z.record(import_zod48.z.string(), import_zod48.z.enum(variantSelectors).default(VariantSelector.menu)).default(() => ({})),
+  variantMode: import_zod48.z.enum(variantModes).default(VariantMode.multiple)
 });
 
 // src/schema/widgets/checkout-and-beyond/products.ts
-var CABProductsSection = import_zod48.z.object({
+var CABProductsSection = import_zod49.z.object({
   ...CABVariableFields,
-  name: import_zod48.z.string().optional(),
-  sectionId: import_zod48.z.uuid().default(() => (0, import_uuid8.v7)()),
-  sections: import_zod48.z.union([import_zod48.z.array(import_zod48.z.lazy(() => CABProductSection)), import_zod48.z.strictObject({}).transform(() => [])]).default(() => []),
-  sectionType: import_zod48.z.literal(SectionType.products).default(SectionType.products)
+  name: import_zod49.z.string().optional(),
+  sectionId: import_zod49.z.uuid().default(() => (0, import_uuid8.v7)()),
+  sections: import_zod49.z.union([import_zod49.z.array(import_zod49.z.lazy(() => CABProductSection)), import_zod49.z.strictObject({}).transform(() => [])]).default(() => []),
+  sectionType: import_zod49.z.literal(SectionType.products).default(SectionType.products)
 });
 
 // src/schema/widgets/checkout-and-beyond/offers.ts
-var CABOffersSection = import_zod49.z.lazy(
+var CABOffersSection = import_zod50.z.lazy(
   () => CABLayoutSection.omit({ sections: true, sectionType: true }).extend({
     /**
      * A rule between consecutive cards in the vertical list — legacy checkout-offers' `<Divider />`,
@@ -3619,8 +3670,8 @@ var CABOffersSection = import_zod49.z.lazy(
      * run of products). Optional, not defaulted: only the v1 converter sets it (REB-24265); a
      * hand-built tree keeps React CAB's dividerless rendering.
      */
-    divider: import_zod49.z.boolean().optional(),
-    sections: import_zod49.z.union([import_zod49.z.array(import_zod49.z.lazy(() => CABSection)), import_zod49.z.strictObject({}).transform(() => [])]).default(() => [
+    divider: import_zod50.z.boolean().optional(),
+    sections: import_zod50.z.union([import_zod50.z.array(import_zod50.z.lazy(() => CABSection)), import_zod50.z.strictObject({}).transform(() => [])]).default(() => [
       CABBannerSection.parse({
         buttonField: "undoAddToOrder",
         color: "success",
@@ -3634,77 +3685,77 @@ var CABOffersSection = import_zod49.z.lazy(
       CABDataSourceSection.parse({}),
       CABProductsSection.parse({})
     ]),
-    sectionType: import_zod49.z.literal(SectionType.offers).default(SectionType.offers)
+    sectionType: import_zod50.z.literal(SectionType.offers).default(SectionType.offers)
   })
 );
 
 // src/schema/widgets/checkout-and-beyond/carousel.ts
-var CABCarouselSection = import_zod50.z.lazy(
+var CABCarouselSection = import_zod51.z.lazy(
   () => CABLayoutSection.omit({ sections: true, sectionType: true }).extend({
-    autoAdvanceInterval: import_zod50.z.number().default(0),
-    itemsAtOnce: import_zod50.z.number().min(1).default(1),
+    autoAdvanceInterval: import_zod51.z.number().default(0),
+    itemsAtOnce: import_zod51.z.number().min(1).default(1),
     /** Card arrangement for the offers child (`horizontal` = side-by-side) — NOT the carousel's own `direction`. */
-    offersDirection: import_zod50.z.enum(offersDirections).default("vertical"),
-    sections: import_zod50.z.union([import_zod50.z.array(import_zod50.z.lazy(() => CABSection)), import_zod50.z.strictObject({}).transform(() => [])]).default(() => [CABOffersSection.parse({})]),
-    sectionType: import_zod50.z.literal(SectionType.carousel).default(SectionType.carousel)
+    offersDirection: import_zod51.z.enum(offersDirections).default("vertical"),
+    sections: import_zod51.z.union([import_zod51.z.array(import_zod51.z.lazy(() => CABSection)), import_zod51.z.strictObject({}).transform(() => [])]).default(() => [CABOffersSection.parse({})]),
+    sectionType: import_zod51.z.literal(SectionType.carousel).default(SectionType.carousel)
   })
 );
 
 // src/schema/widgets/checkout-and-beyond/cartLine.ts
-var import_zod51 = require("zod");
-var CABCartLineSection = import_zod51.z.lazy(
+var import_zod52 = require("zod");
+var CABCartLineSection = import_zod52.z.lazy(
   () => CABLayoutSection.omit({ sections: true, sectionType: true }).extend({
-    sections: import_zod51.z.union([import_zod51.z.array(import_zod51.z.lazy(() => CABSection)), import_zod51.z.strictObject({}).transform(() => [])]).default(() => [CABButtonSection.parse({ action: ButtonAction.switchToSubscription })]),
-    sectionType: import_zod51.z.literal(SectionType.cartLine).default(SectionType.cartLine)
+    sections: import_zod52.z.union([import_zod52.z.array(import_zod52.z.lazy(() => CABSection)), import_zod52.z.strictObject({}).transform(() => [])]).default(() => [CABButtonSection.parse({ action: ButtonAction.switchToSubscription })]),
+    sectionType: import_zod52.z.literal(SectionType.cartLine).default(SectionType.cartLine)
   })
 );
 
 // src/schema/widgets/checkout-and-beyond/discount.ts
 var import_uuid9 = require("uuid");
-var import_zod52 = require("zod");
-var CABDiscountSection = import_zod52.z.object({
+var import_zod53 = require("zod");
+var CABDiscountSection = import_zod53.z.object({
   ...CABVariableFields,
-  amount: import_zod52.z.union([import_zod52.z.number(), import_zod52.z.string()]).catch(0),
-  discountedBy: import_zod52.z.string().optional(),
-  discountedFrom: import_zod52.z.enum(discountSources).optional().catch(void 0),
-  message: import_zod52.z.string().optional(),
-  name: import_zod52.z.string().optional(),
-  quantity: import_zod52.z.number().default(1),
-  sectionId: import_zod52.z.uuid().default(() => (0, import_uuid9.v7)()),
-  sectionType: import_zod52.z.literal(SectionType.discount).default(SectionType.discount),
-  type: import_zod52.z.enum(discountTypes).catch("none")
+  amount: import_zod53.z.union([import_zod53.z.number(), import_zod53.z.string()]).catch(0),
+  discountedBy: import_zod53.z.string().optional(),
+  discountedFrom: import_zod53.z.enum(discountSources).optional().catch(void 0),
+  message: import_zod53.z.string().optional(),
+  name: import_zod53.z.string().optional(),
+  quantity: import_zod53.z.number().default(1),
+  sectionId: import_zod53.z.uuid().default(() => (0, import_uuid9.v7)()),
+  sectionType: import_zod53.z.literal(SectionType.discount).default(SectionType.discount),
+  type: import_zod53.z.enum(discountTypes).catch("none")
 });
 
 // src/schema/widgets/checkout-and-beyond/monetize.ts
 var import_uuid10 = require("uuid");
-var import_zod53 = require("zod");
-var CABMonetizeAds = import_zod53.z.object({
-  requestId: import_zod53.z.string().optional(),
+var import_zod54 = require("zod");
+var CABMonetizeAds = import_zod54.z.object({
+  requestId: import_zod54.z.string().optional(),
   /** Defaulted here, never in the beacon: absence of information is `ads` itself being absent. */
-  testing: import_zod53.z.boolean().default(false)
+  testing: import_zod54.z.boolean().default(false)
 });
-var CABMonetizeSection = import_zod53.z.object({
+var CABMonetizeSection = import_zod54.z.object({
   ...CABVariableFields,
   ads: CABMonetizeAds.optional(),
-  name: import_zod53.z.string().optional(),
+  name: import_zod54.z.string().optional(),
   /**
    * Server-hydrated offer cards (inline hydration): when `/cab/sections` was asked with a `monetize`
    * context block, the composed cards ride the marker itself — `[]` means "hydrated, no fill" (render
    * nothing, skip the fetch); ABSENT means "not hydrated" (the client fetches via `/cab/monetize`).
    */
-  offers: import_zod53.z.array(import_zod53.z.lazy(() => CABSection)).optional(),
+  offers: import_zod54.z.array(import_zod54.z.lazy(() => CABSection)).optional(),
   /** Privacy Policy footer href (the widget's `privacy_policy_url` setting); read server-side for hydration, relayed by the client only on the legacy `/cab/monetize` fallback. */
-  privacyPolicyUrl: import_zod53.z.string().optional(),
-  sectionId: import_zod53.z.uuid().default(() => (0, import_uuid10.v7)()),
-  sectionType: import_zod53.z.literal(SectionType.monetize).default(SectionType.monetize),
+  privacyPolicyUrl: import_zod54.z.string().optional(),
+  sectionId: import_zod54.z.uuid().default(() => (0, import_uuid10.v7)()),
+  sectionType: import_zod54.z.literal(SectionType.monetize).default(SectionType.monetize),
   /** Ads-taxonomy sub-vertical id (the widget's `sub_vertical` setting); paired with `vertical`. */
-  subVertical: import_zod53.z.string().optional(),
+  subVertical: import_zod54.z.string().optional(),
   /** Ads-taxonomy vertical id (the widget's `vertical` setting) — with `subVertical`, the admin Monetize editor's two configurables. */
-  vertical: import_zod53.z.string().optional()
+  vertical: import_zod54.z.string().optional()
 });
 
 // src/schema/widgets/checkout-and-beyond/progressBar.ts
-var import_zod54 = require("zod");
+var import_zod55 = require("zod");
 
 // src/schema/widgets/checkout-and-beyond/giftLabels.ts
 var GIFT_LABELS = {
@@ -3823,34 +3874,34 @@ var GIFT_LABELS = {
 };
 
 // src/schema/widgets/checkout-and-beyond/progressBar.ts
-var CABProgressTierExclusion = import_zod54.z.object({
-  collectionIds: import_zod54.z.array(import_zod54.z.number().int().positive()).default(() => []),
-  productIds: import_zod54.z.array(import_zod54.z.number().int().positive()).default(() => []),
-  tags: import_zod54.z.array(import_zod54.z.string().min(1)).default(() => []),
-  type: import_zod54.z.enum(progressTierExclusionTypes)
+var CABProgressTierExclusion = import_zod55.z.object({
+  collectionIds: import_zod55.z.array(import_zod55.z.number().int().positive()).default(() => []),
+  productIds: import_zod55.z.array(import_zod55.z.number().int().positive()).default(() => []),
+  tags: import_zod55.z.array(import_zod55.z.string().min(1)).default(() => []),
+  type: import_zod55.z.enum(progressTierExclusionTypes)
 });
-var CABProgressTier = import_zod54.z.object({
+var CABProgressTier = import_zod55.z.object({
   /**
    * Order-discount tiers only (onsite `discount`): the reward the order-discount Function applies at
    * cart time, carried so the client can resolve the `{{discountAmount}}` token in this tier's copy.
    * `fixedAmount`: shop-currency CENTS (FX-scaled by the client, like {@link CABProgressTier.threshold});
    * `percentage`: the whole-percent number rendered raw (`{n}%`). Absent on non-discount tiers.
    */
-  discount: import_zod54.z.object({ amount: import_zod54.z.number().nonnegative(), type: import_zod54.z.enum(["fixedAmount", "percentage"]) }).optional(),
+  discount: import_zod55.z.object({ amount: import_zod55.z.number().nonnegative(), type: import_zod55.z.enum(["fixedAmount", "percentage"]) }).optional(),
   /**
    * Per-tier exclusion rules (onsite `exclusions` when `exclusions_enabled`): lines they match don't count
    * toward this tier. Empty (the default, and the converter's output for a disabled or ruleless tier) means
    * the tier measures the plain bar-level adjusted progress. Consumers read ONLY the list named by the rule's
    * `type` — the converter leaves the other two at `[]`, so a populated off-type list never reaches the tree.
    */
-  exclusions: import_zod54.z.array(CABProgressTierExclusion).default(() => []),
+  exclusions: import_zod55.z.array(CABProgressTierExclusion).default(() => []),
   /**
    * Smart-cart product (gift) tiers only (onsite `filter_oos_variants`): when set, the client drops this
    * tier entirely once its gift has NO in-stock eligible variant — the milestone, fill slot and gift
    * controls all disappear, mirroring onsite removing the tier from `bar.tiers` before it renders. Absent
    * on shipping/discount/decorative tiers and left off by default (the tier renders regardless of stock).
    */
-  filterOosVariants: import_zod54.z.boolean().default(false),
+  filterOosVariants: import_zod55.z.boolean().default(false),
   /**
    * Smart-cart product (gift) tiers only: the reward unlocked at this tier. The client enriches
    * `productId`/`variantIds` to live variants (availability, price) and adds the chosen one to the cart
@@ -3858,10 +3909,10 @@ var CABProgressTier = import_zod54.z.object({
    * tiers and on tiers with no configured product. Cart add/remove is a later stage; carried here so the
    * tree is complete.
    */
-  gift: import_zod54.z.object({
-    productId: import_zod54.z.number().int().positive(),
-    title: import_zod54.z.string().optional(),
-    variantIds: import_zod54.z.array(import_zod54.z.number().int().positive()).default(() => [])
+  gift: import_zod55.z.object({
+    productId: import_zod55.z.number().int().positive(),
+    title: import_zod55.z.string().optional(),
+    variantIds: import_zod55.z.array(import_zod55.z.number().int().positive()).default(() => [])
   }).optional(),
   /**
    * The step-row icon's square size in PIXELS (onsite `product_tier_element_size`, an admin px string the
@@ -3881,7 +3932,7 @@ var CABProgressTier = import_zod54.z.object({
    * renderer never spells a fallback), which also makes a tree authored before this field render at
    * React's size rather than the old hardcoded 20.
    */
-  iconSizePx: import_zod54.z.number().int().min(1).max(64).default(18),
+  iconSizePx: import_zod55.z.number().int().min(1).max(64).default(18),
   /**
    * The step-row label at this tier's slot (onsite `getTierLabel`): the merchant custom label, else the
    * type default — 'Free Shipping' or '{n}% Discount'. A PRODUCT tier gets NO converter label: its name is
@@ -3891,35 +3942,35 @@ var CABProgressTier = import_zod54.z.object({
    * turns a blank label into an absent key, and a client-authored blank means the same thing — the renderer
    * emits no caption slot rather than an empty one). Plain text — a compact icon+label.
    */
-  label: import_zod54.z.record(import_zod54.z.string(), import_zod54.z.string()).optional(),
+  label: import_zod55.z.record(import_zod55.z.string(), import_zod55.z.string()).optional(),
   /**
    * Smart-cart product (gift) tiers only (onsite `product_tier_image`): show the gift's product image in
    * the step-row slot instead of the generic bag icon. The converter can't supply the image URL (config
    * carries only product IDs), so the client resolves it (authoritative Shopify featured image, React
    * parity) and falls back to the bag icon when the flag is off or no image resolves. Default false.
    */
-  productTierImage: import_zod54.z.boolean().default(false),
+  productTierImage: import_zod55.z.boolean().default(false),
   /**
    * The tier's goal, measured per `unit`. `currency` (default): SHOP-currency cents — the canonical
    * fallback: when the buyer's presentment currency has no entry in `thresholds`, the client
    * multiplies this by the live FX rate (converter maps the v1 `unlock_price`, e.g. `75` → `7500`).
    * `item`: a raw item count — no cents, no FX, no `thresholds` overrides.
    */
-  threshold: import_zod54.z.number().int().nonnegative(),
+  threshold: import_zod55.z.number().int().nonnegative(),
   /**
    * Per-presentment-currency goal overrides — lowercased ISO currency code → cents (e.g. `{ cad: 9900 }`).
    * When the buyer's currency has an entry, the client uses it verbatim INSTEAD of FX-converting
    * `threshold`, so merchants show intentional, clean per-market amounts (Shopify Markets) rather than a
    * converted base. Defaults to `{}` — no overrides means always fall back to `threshold`.
    */
-  thresholds: import_zod54.z.record(import_zod54.z.string(), import_zod54.z.number().int().nonnegative()).default(() => ({})),
+  thresholds: import_zod55.z.record(import_zod55.z.string(), import_zod55.z.number().int().nonnegative()).default(() => ({})),
   /**
    * Smart-cart tier identifier, mirrored onto the gift cart line's `_tier` attribute so the client can
    * match an in-cart gift back to its tier (add on reach, remove on downgrade/decline). Absent on the
    * shipping bar (single unlabeled tier, no gift).
    */
-  tierId: import_zod54.z.string().optional(),
-  tierType: import_zod54.z.enum(progressTierTypes).default(ProgressTierType.shipping),
+  tierId: import_zod55.z.string().optional(),
+  tierType: import_zod55.z.enum(progressTierTypes).default(ProgressTierType.shipping),
   /**
    * What this tier's progress is measured in — PER TIER (onsite's `unlock_condition_type` model, NOT
    * the React port's bar-level `tiers[0]` shortcut). `currency` compares money cents against the
@@ -3930,9 +3981,9 @@ var CABProgressTier = import_zod54.z.object({
    * count carries no injected noun (no English `item`/`items` inflection on localized copy); merchant
    * template text supplies grammatically-neutral wording around the token.
    */
-  unit: import_zod54.z.enum(progressTierUnits).default(ProgressTierUnit.currency)
+  unit: import_zod55.z.enum(progressTierUnits).default(ProgressTierUnit.currency)
 });
-var CABProgressBarSection = import_zod54.z.lazy(
+var CABProgressBarSection = import_zod55.z.lazy(
   () => CABLayoutSection.omit({ sectionType: true }).extend({
     /**
      * The onsite bar id (smart-cart TPB bars only). The client mirrors it to the cart's `_barId` attribute
@@ -3941,35 +3992,35 @@ var CABProgressBarSection = import_zod54.z.lazy(
      * checkout reaches the extension without it, so the client writes it or the tier gift's 100% discount
      * (and any tier order discount) never applies. Absent on the v1 shipping bar (no gift tiers, no id).
      */
-    barId: import_zod54.z.string().optional(),
+    barId: import_zod55.z.string().optional(),
     /** Empty = shown everywhere; otherwise uppercase ISO country codes. */
-    countryCodes: import_zod54.z.array(import_zod54.z.string().transform((code) => code.trim().toUpperCase())).default(() => []),
+    countryCodes: import_zod55.z.array(import_zod55.z.string().transform((code) => code.trim().toUpperCase())).default(() => []),
     /**
      * Uppercase ISO codes where a higher-precedence geo bar applies, so this (default, non-geo) bar is
      * hidden there — replicates React `getbar`'s geo-match-over-default precedence. Empty = never excluded.
      */
-    excludeCountryCodes: import_zod54.z.array(import_zod54.z.string().transform((code) => code.trim().toUpperCase())).default(() => []),
+    excludeCountryCodes: import_zod55.z.array(import_zod55.z.string().transform((code) => code.trim().toUpperCase())).default(() => []),
     /**
      * Measure progress against the PRE-discount subtotal (onsite `exclude_discount_in_subtotal`, and
      * forced on for bars with a discount tier so its own reward can't un-reach the tier). The client
      * adds the cart's discount allocations back to the live subtotal.
      */
-    excludeDiscountInSubtotal: import_zod54.z.boolean().default(false),
+    excludeDiscountInSubtotal: import_zod55.z.boolean().default(false),
     /** Variant ids the client subtracts from the adjusted subtotal (React `bar.excluded_products`). */
-    excludedVariantIds: import_zod54.z.array(import_zod54.z.number().int().positive()).default(() => []),
+    excludedVariantIds: import_zod55.z.array(import_zod55.z.number().int().positive()).default(() => []),
     /**
      * When the cart holds a subscription item, treat the bar as reached regardless of subtotal (React
      * `free_shipping_on_subscription(s)`). `freeShippingOnAll` is already a zero-threshold tier instead.
      */
-    freeShippingOnSubscription: import_zod54.z.boolean().default(false),
+    freeShippingOnSubscription: import_zod55.z.boolean().default(false),
     /** Localized heading over the gift controls (onsite `gift_area_title`, default 'FREE GIFTS'). */
-    giftAreaTitle: import_zod54.z.record(import_zod54.z.string(), import_zod54.z.string()).default(() => ({ en: "FREE GIFTS" })),
+    giftAreaTitle: import_zod55.z.record(import_zod55.z.string(), import_zod55.z.string()).default(() => ({ en: "FREE GIFTS" })),
     /** Localized gift-control labels (add/remove/heading); a tier's gift `title` beats `yourGift`. */
-    giftLabels: import_zod54.z.object({
-      addGift: import_zod54.z.record(import_zod54.z.string(), import_zod54.z.string()).default(() => ({ ...GIFT_LABELS.addGift })),
-      remove: import_zod54.z.record(import_zod54.z.string(), import_zod54.z.string()).default(() => ({ ...GIFT_LABELS.remove })),
-      selectOptions: import_zod54.z.record(import_zod54.z.string(), import_zod54.z.string()).default(() => ({ ...GIFT_LABELS.selectOptions })),
-      yourGift: import_zod54.z.record(import_zod54.z.string(), import_zod54.z.string()).default(() => ({ ...GIFT_LABELS.yourGift }))
+    giftLabels: import_zod55.z.object({
+      addGift: import_zod55.z.record(import_zod55.z.string(), import_zod55.z.string()).default(() => ({ ...GIFT_LABELS.addGift })),
+      remove: import_zod55.z.record(import_zod55.z.string(), import_zod55.z.string()).default(() => ({ ...GIFT_LABELS.remove })),
+      selectOptions: import_zod55.z.record(import_zod55.z.string(), import_zod55.z.string()).default(() => ({ ...GIFT_LABELS.selectOptions })),
+      yourGift: import_zod55.z.record(import_zod55.z.string(), import_zod55.z.string()).default(() => ({ ...GIFT_LABELS.yourGift }))
     }).default(() => ({
       addGift: { ...GIFT_LABELS.addGift },
       remove: { ...GIFT_LABELS.remove },
@@ -3977,38 +4028,38 @@ var CABProgressBarSection = import_zod54.z.lazy(
       yourGift: { ...GIFT_LABELS.yourGift }
     })),
     /** The bar's a11y label; the merchant names it in the editor, else this default (React parity). */
-    name: import_zod54.z.string().default("Order progress"),
+    name: import_zod55.z.string().default("Order progress"),
     /**
      * Bar fill color. An explicit (widget-authored) value is used verbatim; when absent the server
      * fills it with the live shop theme's `buttonBackground` (React `useRebuyTheme` parity). Still
      * absent after that ⇒ the theme fetch failed and the client renders its platform-default bar —
      * optional, not defaulted, so "merchant chose no color" stays distinguishable from any real value.
      */
-    progressColor: import_zod54.z.string().optional(),
-    sectionType: import_zod54.z.literal(SectionType.progressBar).default(SectionType.progressBar),
+    progressColor: import_zod55.z.string().optional(),
+    sectionType: import_zod55.z.literal(SectionType.progressBar).default(SectionType.progressBar),
     /**
      * The bar's milestones in the merchant's CONFIGURED order — the renderer does NOT sort them (022
      * O-B2: sorting by resolved threshold reversed configured milestones on out-of-order or mixed-unit
      * count-vs-cents bars). Drives the fill (even slot per tier) and, for smart-cart product tiers, the
      * gift add/remove. The visual tier display lives in `sections` (composable), NOT here.
      */
-    tiers: import_zod54.z.union([import_zod54.z.array(CABProgressTier), import_zod54.z.strictObject({}).transform(() => [])]).default(() => [])
+    tiers: import_zod55.z.union([import_zod55.z.array(CABProgressTier), import_zod55.z.strictObject({}).transform(() => [])]).default(() => [])
   })
 );
 
 // src/schema/widgets/checkout-and-beyond/quantity.ts
 var import_uuid11 = require("uuid");
-var import_zod55 = require("zod");
-var CABQuantitySection = import_zod55.z.object({
+var import_zod56 = require("zod");
+var CABQuantitySection = import_zod56.z.object({
   ...CABVariableFields,
-  errorMessages: import_zod55.z.record(
-    import_zod55.z.string(),
-    import_zod55.z.object({
+  errorMessages: import_zod56.z.record(
+    import_zod56.z.string(),
+    import_zod56.z.object({
       /** `{{step}}` is interpolated at render — the off-increment message React never gave a merchant key. */
-      increment: import_zod55.z.string().optional(),
-      max: import_zod55.z.string().optional(),
-      min: import_zod55.z.string().optional(),
-      neg: import_zod55.z.string().optional()
+      increment: import_zod56.z.string().optional(),
+      max: import_zod56.z.string().optional(),
+      min: import_zod56.z.string().optional(),
+      neg: import_zod56.z.string().optional()
     })
   ).default({
     en: {
@@ -4018,18 +4069,18 @@ var CABQuantitySection = import_zod55.z.object({
       neg: "Quantity cannot be negative"
     }
   }),
-  inputType: import_zod55.z.enum(quantityInputs).default(QuantityInput.select),
-  max: import_zod55.z.number().min(1).max(100).default(10),
-  min: import_zod55.z.number().min(1).default(1),
+  inputType: import_zod56.z.enum(quantityInputs).default(QuantityInput.select),
+  max: import_zod56.z.number().min(1).max(100).default(10),
+  min: import_zod56.z.number().min(1).default(1),
   /** The a11y label for the quantity control; the merchant names it in the editor, else this default. */
-  name: import_zod55.z.string().default("Quantity"),
-  sectionId: import_zod55.z.uuid().default(() => (0, import_uuid11.v7)()),
-  sectionType: import_zod55.z.literal(SectionType.quantity).default(SectionType.quantity)
+  name: import_zod56.z.string().default("Quantity"),
+  sectionId: import_zod56.z.uuid().default(() => (0, import_uuid11.v7)()),
+  sectionType: import_zod56.z.literal(SectionType.quantity).default(SectionType.quantity)
 });
 
 // src/schema/widgets/checkout-and-beyond/reviews.ts
 var import_uuid12 = require("uuid");
-var import_zod56 = require("zod");
+var import_zod57 = require("zod");
 
 // src/schema/widgets/checkout-and-beyond/reviewLabels.ts
 var REVIEW_LABELS = {
@@ -4092,68 +4143,68 @@ var REVIEW_LABELS = {
 };
 
 // src/schema/widgets/checkout-and-beyond/reviews.ts
-var CABReviewsSection = import_zod56.z.object({
+var CABReviewsSection = import_zod57.z.object({
   ...CABVariableFields,
-  color: import_zod56.z.string().default("#fadb14"),
+  color: import_zod57.z.string().default("#fadb14"),
   /**
    * Localized review-count templates (`{{reviewCount}}`), one/other plural forms; the client picks the
    * form via `Intl.PluralRules`. Defaults here (schema-first) so every tree localizes without converter
    * or merchant work.
    */
-  countLabels: import_zod56.z.object({
-    one: import_zod56.z.record(import_zod56.z.string(), import_zod56.z.string()).default(() => ({ ...REVIEW_LABELS.one })),
-    other: import_zod56.z.record(import_zod56.z.string(), import_zod56.z.string()).default(() => ({ ...REVIEW_LABELS.other }))
+  countLabels: import_zod57.z.object({
+    one: import_zod57.z.record(import_zod57.z.string(), import_zod57.z.string()).default(() => ({ ...REVIEW_LABELS.one })),
+    other: import_zod57.z.record(import_zod57.z.string(), import_zod57.z.string()).default(() => ({ ...REVIEW_LABELS.other }))
   }).default(() => ({ one: { ...REVIEW_LABELS.one }, other: { ...REVIEW_LABELS.other } })),
-  name: import_zod56.z.string().optional(),
-  sectionId: import_zod56.z.uuid().default(() => (0, import_uuid12.v7)()),
-  sectionType: import_zod56.z.literal(SectionType.reviews).default(SectionType.reviews),
-  size: import_zod56.z.enum(reviewsSizes).default(ReviewsSize.default),
+  name: import_zod57.z.string().optional(),
+  sectionId: import_zod57.z.uuid().default(() => (0, import_uuid12.v7)()),
+  sectionType: import_zod57.z.literal(SectionType.reviews).default(SectionType.reviews),
+  size: import_zod57.z.enum(reviewsSizes).default(ReviewsSize.default),
   /**
    * Star outline color, interpolated into a style by the renderer, so it is hex-constrained like
    * `CABButtonSection.color`. The legacy source (`PostPurchaseSettings.styles.starStrokeColor`) is a free
    * string: its converter must validate and fall back to this default rather than let one odd value drop
    * the whole reviews section.
    */
-  strokeColor: import_zod56.z.string().regex(HEX_COLOR_REGEX).default("#fadb14"),
+  strokeColor: import_zod57.z.string().regex(HEX_COLOR_REGEX).default("#fadb14"),
   /** Star outline width in px; `0` draws no outline. The legacy `styles.strokeWidth` is a STRING ('1') — its converter coerces. */
-  strokeWidth: import_zod56.z.number().nonnegative().default(0)
+  strokeWidth: import_zod57.z.number().nonnegative().default(0)
 });
 
 // src/schema/widgets/checkout-and-beyond/separator.ts
 var import_uuid13 = require("uuid");
-var import_zod57 = require("zod");
-var CABSeparatorSection = import_zod57.z.object({
+var import_zod58 = require("zod");
+var CABSeparatorSection = import_zod58.z.object({
   ...CABVariableFields,
-  sectionId: import_zod57.z.uuid().default(() => (0, import_uuid13.v7)()),
-  sectionType: import_zod57.z.literal(SectionType.separator).default(SectionType.separator)
+  sectionId: import_zod58.z.uuid().default(() => (0, import_uuid13.v7)()),
+  sectionType: import_zod58.z.literal(SectionType.separator).default(SectionType.separator)
 });
 
 // src/schema/widgets/checkout-and-beyond/variants.ts
 var import_compat5 = require("es-toolkit/compat");
 var import_uuid14 = require("uuid");
-var import_zod58 = require("zod");
-var CABVariantsSection = import_zod58.z.object({
+var import_zod59 = require("zod");
+var CABVariantsSection = import_zod59.z.object({
   ...CABVariableFields,
-  hideOutOfStockVariants: import_zod58.z.boolean().default(false),
-  name: import_zod58.z.string().optional(),
-  sectionId: import_zod58.z.uuid().default(() => (0, import_uuid14.v7)()),
-  sectionType: import_zod58.z.literal(SectionType.variants).default(SectionType.variants),
-  selector: import_zod58.z.enum((0, import_compat5.slice)(variantSelectors, 0, 3)).default(VariantSelector.menu),
-  variantMode: import_zod58.z.enum(variantModes).default(VariantMode.multiple)
+  hideOutOfStockVariants: import_zod59.z.boolean().default(false),
+  name: import_zod59.z.string().optional(),
+  sectionId: import_zod59.z.uuid().default(() => (0, import_uuid14.v7)()),
+  sectionType: import_zod59.z.literal(SectionType.variants).default(SectionType.variants),
+  selector: import_zod59.z.enum((0, import_compat5.slice)(variantSelectors, 0, 3)).default(VariantSelector.menu),
+  variantMode: import_zod59.z.enum(variantModes).default(VariantMode.multiple)
 });
 
 // src/schema/widgets/checkout-and-beyond/shared.ts
-var CABBorder = import_zod59.z.object({
-  radius: import_zod59.z.enum(borderRadii).default(BorderRadius.base),
-  style: import_zod59.z.enum(borderStyles).default(BorderStyle.none),
-  width: import_zod59.z.enum(borderWidths).default(BorderWidth.base)
+var CABBorder = import_zod60.z.object({
+  radius: import_zod60.z.enum(borderRadii).default(BorderRadius.base),
+  style: import_zod60.z.enum(borderStyles).default(BorderStyle.none),
+  width: import_zod60.z.enum(borderWidths).default(BorderWidth.base)
 }).default({
   radius: BorderRadius.base,
   style: BorderStyle.none,
   width: BorderWidth.base
 });
-var CABSection = import_zod59.z.lazy(
-  () => import_zod59.z.discriminatedUnion("sectionType", [
+var CABSection = import_zod60.z.lazy(
+  () => import_zod60.z.discriminatedUnion("sectionType", [
     CABBannerSection,
     CABButtonSection,
     CABCarouselSection,
@@ -4176,41 +4227,41 @@ var CABSection = import_zod59.z.lazy(
 );
 
 // src/schema/widgets/checkout-and-beyond/layout.ts
-var GridItem = import_zod60.z.union([import_zod60.z.literal("auto"), import_zod60.z.literal("fill"), import_zod60.z.string().regex(/^\d+%$/), import_zod60.z.number()]);
-var CABLayoutWrapping = import_zod60.z.object({
-  breakAt: import_zod60.z.number().positive(),
-  maxPerLine: import_zod60.z.number().int().positive()
+var GridItem = import_zod61.z.union([import_zod61.z.literal("auto"), import_zod61.z.literal("fill"), import_zod61.z.string().regex(/^\d+%$/), import_zod61.z.number()]);
+var CABLayoutWrapping = import_zod61.z.object({
+  breakAt: import_zod61.z.number().positive(),
+  maxPerLine: import_zod61.z.number().int().positive()
 });
-var CABLayoutSection = import_zod60.z.object({
+var CABLayoutSection = import_zod61.z.object({
   ...CABVariableFields,
-  alignment: import_zod60.z.object({
-    horizontal: import_zod60.z.enum(horizontalAlignments).default(HorizontalAlignment.start),
-    vertical: import_zod60.z.enum(verticalAlignments).default(VerticalAlignment.top)
+  alignment: import_zod61.z.object({
+    horizontal: import_zod61.z.enum(horizontalAlignments).default(HorizontalAlignment.start),
+    vertical: import_zod61.z.enum(verticalAlignments).default(VerticalAlignment.top)
   }).default({
     horizontal: HorizontalAlignment.start,
     vertical: VerticalAlignment.top
   }),
-  border: import_zod60.z.lazy(() => CABBorder),
-  buttonField: import_zod60.z.enum(buttonFields).optional(),
-  direction: import_zod60.z.enum(directions).default(Direction.rows),
+  border: import_zod61.z.lazy(() => CABBorder),
+  buttonField: import_zod61.z.enum(buttonFields).optional(),
+  direction: import_zod61.z.enum(directions).default(Direction.rows),
   /**
    * Platform chrome around the section, not a layout behavior: `callout` is a subdued box with block borders
    * (the legacy post-purchase callout banner), `offer-content` the post-purchase offer's own content card.
    */
-  frame: import_zod60.z.enum(layoutFrames).optional(),
-  grid: import_zod60.z.object({
-    columns: import_zod60.z.union([import_zod60.z.array(GridItem), import_zod60.z.undefined()]).default(() => ["auto"]),
-    rows: import_zod60.z.union([import_zod60.z.array(GridItem), import_zod60.z.undefined()]).default(() => ["auto"])
+  frame: import_zod61.z.enum(layoutFrames).optional(),
+  grid: import_zod61.z.object({
+    columns: import_zod61.z.union([import_zod61.z.array(GridItem), import_zod61.z.undefined()]).default(() => ["auto"]),
+    rows: import_zod61.z.union([import_zod61.z.array(GridItem), import_zod61.z.undefined()]).default(() => ["auto"])
   }).default({ columns: ["auto"], rows: ["auto"] }).optional(),
-  name: import_zod60.z.string().optional(),
-  padding: import_zod60.z.enum(spacings).default(Spacing.none),
-  sectionId: import_zod60.z.uuid().default(() => (0, import_uuid15.v7)()),
-  sections: import_zod60.z.union([import_zod60.z.array(import_zod60.z.lazy(() => CABSection)), import_zod60.z.strictObject({}).transform(() => [])]).default(() => []),
-  sectionType: import_zod60.z.literal(SectionType.layout).default(SectionType.layout),
-  spacing: import_zod60.z.enum(spacings).default(Spacing.base),
+  name: import_zod61.z.string().optional(),
+  padding: import_zod61.z.enum(spacings).default(Spacing.none),
+  sectionId: import_zod61.z.uuid().default(() => (0, import_uuid15.v7)()),
+  sections: import_zod61.z.union([import_zod61.z.array(import_zod61.z.lazy(() => CABSection)), import_zod61.z.strictObject({}).transform(() => [])]).default(() => []),
+  sectionType: import_zod61.z.literal(SectionType.layout).default(SectionType.layout),
+  spacing: import_zod61.z.enum(spacings).default(Spacing.base),
   /** Fire-and-forget impression pixel POSTed once when the section is shown (e.g. a Monetize offer view). */
-  viewUrl: import_zod60.z.string().optional(),
-  width: import_zod60.z.number().default(100),
+  viewUrl: import_zod61.z.string().optional(),
+  width: import_zod61.z.number().default(100),
   wrapping: CABLayoutWrapping.optional()
 });
 
@@ -4232,8 +4283,8 @@ var UI_LABELS = {
 };
 
 // src/schema/widgets/checkout-and-beyond/root.ts
-var localized = (fallback) => import_zod61.z.record(import_zod61.z.string(), import_zod61.z.string()).default(() => ({ ...fallback })).transform((labels) => Object.keys(labels).length > 0 ? labels : { ...fallback });
-var CABUILabels = import_zod61.z.object({
+var localized = (fallback) => import_zod62.z.record(import_zod62.z.string(), import_zod62.z.string()).default(() => ({ ...fallback })).transform((labels) => Object.keys(labels).length > 0 ? labels : { ...fallback });
+var CABUILabels = import_zod62.z.object({
   currentPage: localized(UI_LABELS.currentPage),
   guest: localized(UI_LABELS.guest),
   loadingOptions: localized(UI_LABELS.loadingOptions),
@@ -4258,47 +4309,47 @@ var CABUILabels = import_zod61.z.object({
   subscriptionOptions: { ...UI_LABELS.subscriptionOptions },
   updating: { ...UI_LABELS.updating }
 }));
-var TargetArea = import_zod61.z.object({
-  fill: import_zod61.z.boolean().optional(),
-  flip: import_zod61.z.enum(["both", "horizontal", "vertical"]).optional(),
-  icon: import_zod61.z.string(),
-  label: import_zod61.z.string(),
-  width: import_zod61.z.string()
+var TargetArea = import_zod62.z.object({
+  fill: import_zod62.z.boolean().optional(),
+  flip: import_zod62.z.enum(["both", "horizontal", "vertical"]).optional(),
+  icon: import_zod62.z.string(),
+  label: import_zod62.z.string(),
+  width: import_zod62.z.string()
 }).default(targetAreas[EditorMode.checkoutExtension][1]);
-var CABTracking = import_zod61.z.object({
-  enableAttribution: import_zod61.z.boolean().nullish().transform((value) => value ?? true),
-  enableSource: import_zod61.z.boolean().nullish().transform((value) => value ?? true),
-  enableWidget: import_zod61.z.boolean().nullish().transform((value) => value ?? true)
+var CABTracking = import_zod62.z.object({
+  enableAttribution: import_zod62.z.boolean().nullish().transform((value) => value ?? true),
+  enableSource: import_zod62.z.boolean().nullish().transform((value) => value ?? true),
+  enableWidget: import_zod62.z.boolean().nullish().transform((value) => value ?? true)
 }).nullish().transform((value) => value ?? { enableAttribution: true, enableSource: true, enableWidget: true });
-var CABExperiment = import_zod61.z.object({
-  elementId: import_zod61.z.number(),
-  experimentId: import_zod61.z.number(),
-  experimentType: import_zod61.z.string(),
-  selectedId: import_zod61.z.number()
+var CABExperiment = import_zod62.z.object({
+  elementId: import_zod62.z.number(),
+  experimentId: import_zod62.z.number(),
+  experimentType: import_zod62.z.string(),
+  selectedId: import_zod62.z.number()
 });
 var CABRootSection = CABLayoutSection.extend({
-  editorMode: import_zod61.z.enum(editorModes).default(EditorMode.checkoutExtension),
+  editorMode: import_zod62.z.enum(editorModes).default(EditorMode.checkoutExtension),
   experiment: CABExperiment.optional(),
   // Same rule as CABTracking above: the v1 converters pass raw legacy `previewMode` through, so a
   // `null` must fall back rather than throw the widget; malformed values still throw.
-  previewMode: import_zod61.z.boolean().nullish().transform((value) => value ?? false),
-  storeId: import_zod61.z.number().nullable().default(null),
+  previewMode: import_zod62.z.boolean().nullish().transform((value) => value ?? false),
+  storeId: import_zod62.z.number().nullable().default(null),
   targetArea: TargetArea.nullable(),
   tracking: CABTracking,
-  type: import_zod61.z.enum(widgetTypes).default(WidgetType.ui_extension_content_block),
+  type: import_zod62.z.enum(widgetTypes).default(WidgetType.ui_extension_content_block),
   uiLabels: CABUILabels,
-  version: import_zod61.z.literal(2).default(2),
-  widgetId: import_zod61.z.number().nullable().default(null)
+  version: import_zod62.z.literal(2).default(2),
+  widgetId: import_zod62.z.number().nullable().default(null)
 });
 
 // src/schema/postPurchaseProductView.ts
-var PostPurchaseProductView = import_zod62.z.union([
-  import_zod62.z.object({
+var PostPurchaseProductView = import_zod63.z.union([
+  import_zod63.z.object({
     groupCatalog: PostPurchaseGroupCatalog.optional(),
     initialVariant: PostPurchaseVariantSelector.optional(),
     planCatalog: PostPurchasePlanCatalog.nullable().optional(),
     preparation: PreparedPostPurchaseProduct.extend({
-      display: PreparedPostPurchaseProduct.shape.display.extend({ description: import_zod62.z.string().nullable() }).refine(
+      display: PreparedPostPurchaseProduct.shape.display.extend({ description: import_zod63.z.string().nullable() }).refine(
         ({ description, descriptionDocument }) => description === null === (descriptionDocument !== void 0),
         "Exactly one of the plain and rich descriptions is shown"
       )
@@ -4307,33 +4358,33 @@ var PostPurchaseProductView = import_zod62.z.union([
     sections: CABRootSection,
     variantCatalog: PostPurchaseVariantCatalog.optional()
   }),
-  import_zod62.z.object({
+  import_zod63.z.object({
     groupCatalog: PostPurchaseGroupCatalog.optional(),
     initialVariant: PostPurchaseVariantSelector.optional(),
     planCatalog: PostPurchasePlanCatalog.nullable().optional(),
     preparation: PostPurchasePreparation.options[1],
     purchaseOptions: PostPurchaseOptions.optional(),
-    sections: import_zod62.z.null(),
+    sections: import_zod63.z.null(),
     variantCatalog: PostPurchaseVariantCatalog.optional()
   })
 ]);
 
 // src/schema/postPurchaseProductCollectionView.ts
-var PostPurchaseProductCollectionView = import_zod63.z.object({
-  members: import_zod63.z.array(
-    import_zod63.z.object({
+var PostPurchaseProductCollectionView = import_zod64.z.object({
+  members: import_zod64.z.array(
+    import_zod64.z.object({
       productId: PostPurchaseProductId,
-      productIndex: import_zod63.z.number().int().nonnegative(),
+      productIndex: import_zod64.z.number().int().nonnegative(),
       view: PostPurchaseProductView
     })
   )
 });
-var PostPurchaseCollectionChoice = import_zod63.z.object({
+var PostPurchaseCollectionChoice = import_zod64.z.object({
   choice: PostPurchaseChoice.optional(),
   productId: PostPurchaseProductId,
   variantId: PostPurchaseVariantSelector.shape.variantId.optional()
 }).strict();
-var PostPurchaseExcludedProductIds = import_zod63.z.array(PostPurchaseProductId).default([]);
+var PostPurchaseExcludedProductIds = import_zod64.z.array(PostPurchaseProductId).default([]);
 var PostPurchaseMemberSelector = PostPurchaseProgressSchema.shape.members.element.pick({ productId: true }).extend({ progressRevision: PostPurchaseProgressSchema.shape.revision });
 var PostPurchaseMemberPointer = PostPurchaseProgressSchema.shape.members.element.omit({ status: true }).extend({
   entryRevision: PostPurchaseProgressSchema.shape.entryRevision,
@@ -4346,7 +4397,7 @@ var PostPurchaseQuantityChoice = PostPurchaseCollectionChoice.extend({ quantity:
 var PostPurchaseQuantityPolicy = PostPurchaseSettings.shape.quantityInputs.omit({ defaultQuantity: true }).extend({
   initialQuantity: quantity,
   maxValue: quantity,
-  minValue: import_zod64.z.literal(0).transform(() => 1).or(quantity)
+  minValue: import_zod65.z.literal(0).transform(() => 1).or(quantity)
 }).refine(({ maxValue, minValue }) => minValue <= maxValue, "Quantity bounds are reversed");
 
 // src/schema/postPurchaseGroup.ts
@@ -4354,39 +4405,143 @@ var PostPurchaseGroupChoice = PostPurchaseQuantityChoice.extend({
   memberProductId: PreparedPostPurchaseProduct.shape.selection.shape.productId
 });
 
+// src/schema/postPurchaseHealth.ts
+var import_zod68 = require("zod");
+
+// src/schema/postPurchaseHealthSchedule.ts
+var import_zod67 = require("zod");
+
+// src/schema/postPurchaseReleaseSchedule.ts
+var import_zod66 = require("zod");
+var postPurchaseTaskNameSchema = (queue, id) => import_zod66.z.string().regex(new RegExp(`^projects/[a-zA-Z0-9.:-]+/locations/us-central1/queues/${queue}/tasks/${id}$`));
+var SessionReleaseScheduleRequestSchema = import_zod66.z.strictObject({
+  deadline: PostPurchaseTimestampSchema,
+  orderId: PostPurchaseOrderIdSchema,
+  releaseOwner: ReleaseOwnerSchema,
+  sessionId: PostPurchaseSessionIdSchema
+});
+var SessionReleaseScheduleResponseSchema = import_zod66.z.object({
+  data: import_zod66.z.discriminatedUnion("status", [
+    SessionReleaseScheduleRequestSchema.extend({
+      releaseOwner: import_zod66.z.literal("rebuy"),
+      status: import_zod66.z.literal("queued"),
+      taskName: postPurchaseTaskNameSchema("post-purchase-order-hold-release", "[a-f0-9]{64}-release")
+    }),
+    SessionReleaseScheduleRequestSchema.extend({
+      releaseOwner: import_zod66.z.literal("shopify"),
+      status: import_zod66.z.literal("native")
+    })
+  ]),
+  successful: import_zod66.z.literal(true)
+});
+
+// src/schema/postPurchaseHealthSchedule.ts
+var postPurchaseHealthTaskId = ({ orderId, shop }) => `${shop.replace(/\.myshopify\.com$/, "")}--${orderId.replace("gid://shopify/Order/", "")}`;
+var PostPurchaseHealthTaskNameSchema = postPurchaseTaskNameSchema(
+  "post-purchase-health-check",
+  "[a-z0-9][a-z0-9-]*--[1-9][0-9]*"
+);
+var HealthScheduleAcknowledgementSchema = import_zod67.z.strictObject({
+  data: HealthScheduleSchema.extend({
+    status: import_zod67.z.literal("queued"),
+    taskName: PostPurchaseHealthTaskNameSchema
+  }).refine(
+    (data) => data.taskName.endsWith(`/tasks/${postPurchaseHealthTaskId(data)}`),
+    "taskName must be this order's health task"
+  ),
+  successful: import_zod67.z.literal(true)
+});
+
+// src/schema/postPurchaseHealth.ts
+var HealthFactSchema = HealthScheduleSchema.pick({
+  healthScheduledAt: true,
+  operationId: true,
+  removePartialOrder: true
+});
+var HealthScheduleReceiptSchema = import_zod68.z.strictObject({
+  recordedAt: PostPurchaseTimestampSchema,
+  taskName: PostPurchaseHealthTaskNameSchema
+});
+var StoredHealthFactSchema = HealthFactSchema.extend({ scheduleReceipt: HealthScheduleReceiptSchema.optional() });
+var HealthAttemptSchema = StoredHealthFactSchema.extend({
+  attemptedAt: PostPurchaseTimestampSchema,
+  attemptId: import_zod68.z.uuid(),
+  status: import_zod68.z.literal("attempted")
+});
+var HealthResultSchema = HealthAttemptSchema.extend({
+  finishedAt: PostPurchaseTimestampSchema,
+  status: import_zod68.z.enum(["returned", "unknown"])
+});
+var HealthStateSchema = import_zod68.z.union([
+  StoredHealthFactSchema.extend({ status: import_zod68.z.literal("pending") }),
+  HealthAttemptSchema,
+  HealthResultSchema
+]);
+var HealthPrepareRequestSchema = DecideRequestSchema.extend({
+  operationId: HealthScheduleSchema.shape.operationId
+}).strict();
+var HealthPrepareResponseSchema = import_zod68.z.object({ data: HealthScheduleSchema, successful: import_zod68.z.literal(true) });
+var HealthClaimRequestSchema = import_zod68.z.strictObject({
+  orderId: PostPurchaseOrderIdSchema,
+  removePartialOrder: import_zod68.z.boolean(),
+  shop: ShopifyDomainSchema
+});
+var HealthClaimFactSchema = HealthClaimRequestSchema.extend({
+  healthScheduledAt: HealthFactSchema.shape.healthScheduledAt
+});
+var HealthClaimResponseSchema = import_zod68.z.object({
+  data: import_zod68.z.union([
+    import_zod68.z.strictObject({ status: import_zod68.z.literal("missing") }),
+    HealthClaimFactSchema.extend({ status: import_zod68.z.enum(["pending", "attempted", "returned", "unknown"]) }),
+    HealthClaimFactSchema.extend({ attemptId: HealthAttemptSchema.shape.attemptId, status: import_zod68.z.literal("claimed") })
+  ]),
+  successful: import_zod68.z.literal(true)
+});
+var HealthResultRequestSchema = HealthClaimRequestSchema.extend({
+  attemptId: HealthAttemptSchema.shape.attemptId,
+  outcome: HealthResultSchema.shape.status
+});
+var HealthResultResponseSchema = import_zod68.z.object({
+  data: HealthClaimFactSchema.extend({
+    finishedAt: HealthResultSchema.shape.finishedAt,
+    status: HealthResultSchema.shape.status
+  }),
+  successful: import_zod68.z.literal(true)
+});
+
 // src/schema/postPurchaseLifecycle.ts
-var import_zod65 = require("zod");
-var Presentation = import_zod65.z.strictObject({
+var import_zod69 = require("zod");
+var Presentation = import_zod69.z.strictObject({
   member: PostPurchaseMemberIdentity,
   selectedProductId: PostPurchaseMemberIdentity.shape.productId.optional(),
   variant: PostPurchaseVariantSelector
 });
 var LifecycleObservationRequestSchema = DecideRequestSchema.extend({
   entryRevision: PostPurchaseProgressSchema.shape.entryRevision,
-  eventType: import_zod65.z.enum(["OFFER_VIEWED", "OFFER_TIMER_EXPIRED"]),
+  eventType: import_zod69.z.enum(["OFFER_VIEWED", "OFFER_TIMER_EXPIRED"]),
   presentation: Presentation.nullable(),
   progressRevision: PostPurchaseProgressSchema.shape.revision,
-  requestId: import_zod65.z.uuid()
+  requestId: import_zod69.z.uuid()
 }).strict().refine(
   ({ eventType, presentation }) => eventType !== "OFFER_VIEWED" || presentation !== null,
   "Viewed observations require a presented product"
 );
-var LifecycleObservationResponseSchema = import_zod65.z.object({
-  data: import_zod65.z.strictObject({
+var LifecycleObservationResponseSchema = import_zod69.z.object({
+  data: import_zod69.z.strictObject({
     requestId: LifecycleObservationRequestSchema.shape.requestId,
-    status: import_zod65.z.union([AcceptedEventOutcomeSchema, import_zod65.z.literal("unavailable")])
+    status: import_zod69.z.union([AcceptedEventOutcomeSchema, import_zod69.z.literal("unavailable")])
   }),
-  successful: import_zod65.z.literal(true)
+  successful: import_zod69.z.literal(true)
 });
 
 // src/schema/postPurchaseOffer.ts
-var import_zod67 = require("zod");
+var import_zod71 = require("zod");
 
 // src/schema/postPurchaseSkipTrace.ts
-var import_zod66 = require("zod");
+var import_zod70 = require("zod");
 var POST_PURCHASE_SKIP_LIMIT = 32;
-var PostPurchaseSkipTraceSchema = import_zod66.z.array(
-  import_zod66.z.object({
+var PostPurchaseSkipTraceSchema = import_zod70.z.array(
+  import_zod70.z.object({
     entry: DecisionEntrySchema,
     reason: PostPurchaseSkipReasonSchema
   })
@@ -4394,66 +4549,66 @@ var PostPurchaseSkipTraceSchema = import_zod66.z.array(
 
 // src/schema/postPurchaseOffer.ts
 var OfferPreparationRequestSchema = DecideRequestSchema.strict();
-var OfferPreparationResponseSchema = import_zod67.z.object({
-  data: import_zod67.z.object({ attemptedSkips: PostPurchaseSkipTraceSchema.optional(), progress: PostPurchaseProgressSchema }),
-  successful: import_zod67.z.literal(true)
+var OfferPreparationResponseSchema = import_zod71.z.object({
+  data: import_zod71.z.object({ attemptedSkips: PostPurchaseSkipTraceSchema.optional(), progress: PostPurchaseProgressSchema }),
+  successful: import_zod71.z.literal(true)
 });
 
 // src/schema/postPurchaseOfferEligibility.ts
-var import_zod68 = require("zod");
+var import_zod72 = require("zod");
 var selection = PreparedPostPurchaseProduct.shape.selection;
-var PostPurchaseOfferSkipReason = import_zod68.z.enum(["empty", "no-eligible-subscription"]);
-var PostPurchaseOfferEligibilityContext = import_zod68.z.object({
+var PostPurchaseOfferSkipReason = import_zod72.z.enum(["empty", "no-eligible-subscription"]);
+var PostPurchaseOfferEligibilityContext = import_zod72.z.object({
   excludedProductIds: PostPurchaseExcludedProductIds,
-  originalLineItems: import_zod68.z.array(selection.pick({ productId: true, sellingPlanId: true, variantId: true }))
+  originalLineItems: import_zod72.z.array(selection.pick({ productId: true, sellingPlanId: true, variantId: true }))
 });
-var PostPurchaseOfferEligibility = import_zod68.z.discriminatedUnion("status", [
-  import_zod68.z.object({
-    members: import_zod68.z.array(
-      import_zod68.z.object({ productId: selection.shape.productId, productIndex: import_zod68.z.number().int().nonnegative() })
+var PostPurchaseOfferEligibility = import_zod72.z.discriminatedUnion("status", [
+  import_zod72.z.object({
+    members: import_zod72.z.array(
+      import_zod72.z.object({ productId: selection.shape.productId, productIndex: import_zod72.z.number().int().nonnegative() })
     ),
-    status: import_zod68.z.literal("retain")
+    status: import_zod72.z.literal("retain")
   }),
-  import_zod68.z.object({ reason: PostPurchaseOfferSkipReason, status: import_zod68.z.literal("skip") }),
-  import_zod68.z.object({ reason: import_zod68.z.literal("eligible-upgrade").optional(), status: import_zod68.z.literal("unavailable") })
+  import_zod72.z.object({ reason: PostPurchaseOfferSkipReason, status: import_zod72.z.literal("skip") }),
+  import_zod72.z.object({ reason: import_zod72.z.literal("eligible-upgrade").optional(), status: import_zod72.z.literal("unavailable") })
 ]);
 
 // src/schema/postPurchaseOfferPresentation.ts
-var import_zod69 = require("zod");
+var import_zod73 = require("zod");
 var language2 = PostPurchaseSettings.shape.language.shape.global.unwrap().unwrap();
-var PostPurchaseOfferPresentation = import_zod69.z.strictObject({
+var PostPurchaseOfferPresentation = import_zod73.z.strictObject({
   labels: language2.pick({ declineAll: true, declineThisOffer: true }),
   layout: PostPurchaseSettings.shape.offersLayout,
   sections: CABRootSection.nullable(),
   showDeclineAll: PostPurchaseSettings.shape.productOptions.shape.showDeclineAll
 });
 var OfferPresentationRequestSchema = DecideRequestSchema.strict();
-var OfferPresentationResponseSchema = import_zod69.z.object({
-  data: import_zod69.z.strictObject({
+var OfferPresentationResponseSchema = import_zod73.z.object({
+  data: import_zod73.z.strictObject({
     presentation: PostPurchaseOfferPresentation.nullable(),
     progress: PostPurchaseProgressSchema.nullable(),
     serverNow: PostPurchaseTimestampSchema
   }),
-  successful: import_zod69.z.literal(true)
+  successful: import_zod73.z.literal(true)
 });
 
 // src/schema/postPurchaseOrderDecision.ts
-var import_zod70 = require("zod");
-var OrderDecisionSchema = import_zod70.z.discriminatedUnion("owner", [
-  import_zod70.z.object({ owner: import_zod70.z.literal("session"), sessionId: import_zod70.z.string().regex(/^[a-f0-9]{64}$/) }),
-  import_zod70.z.object({ owner: import_zod70.z.literal("release"), sessionId: import_zod70.z.null() })
+var import_zod74 = require("zod");
+var OrderDecisionSchema = import_zod74.z.discriminatedUnion("owner", [
+  import_zod74.z.object({ owner: import_zod74.z.literal("session"), sessionId: PostPurchaseSessionIdSchema }),
+  import_zod74.z.object({ owner: import_zod74.z.literal("release"), sessionId: import_zod74.z.null() })
 ]);
 
 // src/schema/postPurchasePolicy.ts
-var import_zod71 = require("zod");
-var HoldSettingSchema = import_zod71.z.discriminatedUnion("enabled", [
-  import_zod71.z.object({ durationMinutes: import_zod71.z.number().int().min(1).max(60), enabled: import_zod71.z.literal(true) }),
-  import_zod71.z.object({ durationMinutes: import_zod71.z.null(), enabled: import_zod71.z.literal(false) })
+var import_zod75 = require("zod");
+var HoldSettingSchema = import_zod75.z.discriminatedUnion("enabled", [
+  import_zod75.z.object({ durationMinutes: import_zod75.z.number().int().min(1).max(60), enabled: import_zod75.z.literal(true) }),
+  import_zod75.z.object({ durationMinutes: import_zod75.z.null(), enabled: import_zod75.z.literal(false) })
 ]);
-var TimingSettingsSchema = import_zod71.z.object({ flowHold: HoldSettingSchema, shopHold: HoldSettingSchema });
+var TimingSettingsSchema = import_zod75.z.object({ flowHold: HoldSettingSchema, shopHold: HoldSettingSchema });
 var SessionPolicySchema = TimingSettingsSchema.extend({
-  durationMinutes: import_zod71.z.number().int().min(1).max(60).nullable(),
-  source: import_zod71.z.enum(["shop", "flow", "native"])
+  durationMinutes: import_zod75.z.number().int().min(1).max(60).nullable(),
+  source: import_zod75.z.enum(["shop", "flow", "native"])
 }).refine(
   (policy) => {
     const expectedSource = policy.shopHold.enabled ? "shop" : policy.flowHold.enabled ? "flow" : "native";
@@ -4467,8 +4622,8 @@ var SessionPolicySchema = TimingSettingsSchema.extend({
 );
 
 // src/schema/postPurchasePreparationOptions.ts
-var import_zod72 = require("zod");
-var PostPurchasePreparationOptions = import_zod72.z.object({
+var import_zod76 = require("zod");
+var PostPurchasePreparationOptions = import_zod76.z.object({
   choice: PostPurchaseChoice.optional(),
   member: PostPurchaseMemberSelector.strict().optional(),
   quantity: PreparedPostPurchaseProduct.shape.selection.shape.quantity.optional(),
@@ -4480,8 +4635,8 @@ var PostPurchasePreparationOptions = import_zod72.z.object({
 );
 
 // src/schema/postPurchaseProductSettings.ts
-var import_zod73 = require("zod");
-var amount = import_zod73.z.union([import_zod73.z.number().nonnegative(), PostPurchaseAmount.transform(Number)]);
+var import_zod77 = require("zod");
+var amount = import_zod77.z.union([import_zod77.z.number().nonnegative(), PostPurchaseAmount.transform(Number)]);
 var PostPurchaseProductSettings = PostPurchaseSettings.pick({
   discountedFrom: true,
   language: true,
@@ -4493,50 +4648,62 @@ var PostPurchaseProductSettings = PostPurchaseSettings.pick({
   subscriptionIsDefault: true,
   upgradeToSubscription: true
 }).extend({
-  advance: import_zod73.z.unknown().default({}),
-  blocks: import_zod73.z.array(import_zod73.z.unknown()).optional(),
+  advance: import_zod77.z.unknown().default({}),
+  blocks: import_zod77.z.array(import_zod77.z.unknown()).optional(),
   discount: PostPurchaseSettings.shape.discount.extend({ amount: amount.default(30) }),
-  integrations: import_zod73.z.unknown().default({}),
+  integrations: import_zod77.z.unknown().default({}),
   shipping: PostPurchaseSettings.shape.shipping.extend({ amount: amount.default(10) }),
-  styles: import_zod73.z.unknown().default({}),
+  styles: import_zod77.z.unknown().default({}),
   subImages: PostPurchaseSettings.shape.subImages.catch(null),
-  subscription: import_zod73.z.unknown().default(PostPurchaseSettings.shape.subscription.parse(void 0))
+  subscription: import_zod77.z.unknown().default(PostPurchaseSettings.shape.subscription.parse(void 0))
 });
 
 // src/schema/postPurchaseRecovery.ts
-var import_zod74 = require("zod");
+var import_zod78 = require("zod");
 var PurchaseRecoveryRequestSchema = DecideRequestSchema.strict();
-var PurchaseRecoveryResponseSchema = import_zod74.z.object({
-  data: import_zod74.z.object({
-    operation: import_zod74.z.object({
+var PurchaseRecoveryResponseSchema = import_zod78.z.object({
+  data: import_zod78.z.object({
+    operation: import_zod78.z.object({
       observation: RecordedPurchaseObservationSchema.nullable(),
       operationId: PurchaseReceiptSchema.shape.operationId
     }).strict().nullable(),
     progress: PostPurchaseProgressSchema.nullable().optional()
   }),
-  successful: import_zod74.z.literal(true)
+  successful: import_zod78.z.literal(true)
+});
+
+// src/schema/postPurchaseReleaseClaim.ts
+var import_zod79 = require("zod");
+var ReleaseClaimRequestSchema = ReleaseAuthorityRequestSchema;
+var ReleaseClaimResponseSchema = import_zod79.z.object({
+  data: import_zod79.z.discriminatedUnion("status", [
+    import_zod79.z.object({ status: import_zod79.z.literal("release-permitted") }),
+    PendingReleaseAuthoritySchema,
+    ReadyReleaseAuthoritySchema
+  ]),
+  successful: import_zod79.z.literal(true)
 });
 
 // src/schema/postPurchaseSelection.ts
-var import_zod75 = require("zod");
+var import_zod80 = require("zod");
 var SelectionClaimsSchema = DecideRequestSchema.extend({
   appId: PostPurchaseAppIdSchema,
   entry: DecisionEntrySchema,
-  iss: import_zod75.z.literal("rebuy-api"),
-  purpose: import_zod75.z.literal("post-purchase-selection")
+  iss: import_zod80.z.literal("rebuy-api"),
+  purpose: import_zod80.z.literal("post-purchase-selection")
 });
 var SessionStartRequestSchema = DecideRequestSchema.extend({
-  selectionToken: import_zod75.z.string().min(1).max(8192).optional()
+  selectionToken: import_zod80.z.string().min(1).max(8192).optional()
 }).strict();
 
 // src/schema/postPurchaseSession.ts
-var import_zod76 = require("zod");
+var import_zod81 = require("zod");
 var SessionIdentitySchema = DecideRequestSchema.extend({ appId: PostPurchaseAppIdSchema });
-var SessionOrderTimingSchema = import_zod76.z.object({
+var SessionOrderTimingSchema = import_zod81.z.object({
   nativeDeadline: PostPurchaseTimestampSchema,
   orderCreatedAt: PostPurchaseTimestampSchema,
   orderId: PostPurchaseOrderIdSchema,
-  timingSource: import_zod76.z.literal("shopify-order-created-at")
+  timingSource: import_zod81.z.literal("shopify-order-created-at")
 });
 var ReadySessionTimingSchema = SessionOrderTimingSchema.extend({
   deadline: PostPurchaseTimestampSchema,
@@ -4553,33 +4720,33 @@ var ReadySessionTimingSchema = SessionOrderTimingSchema.extend({
   message: "deadline must not exceed nativeDeadline",
   path: ["deadline"]
 });
-var SessionStartResponseSchema = import_zod76.z.object({
-  data: import_zod76.z.object({
-    phase: import_zod76.z.literal("render"),
+var SessionStartResponseSchema = import_zod81.z.object({
+  data: import_zod81.z.object({
+    phase: import_zod81.z.literal("render"),
     serverNow: PostPurchaseTimestampSchema,
     session: ReadySessionTimingSchema,
-    workflowPhase: import_zod76.z.literal("start")
+    workflowPhase: import_zod81.z.literal("start")
   }),
-  successful: import_zod76.z.literal(true)
+  successful: import_zod81.z.literal(true)
 });
 
 // src/schema/postPurchaseShadow.ts
-var import_zod77 = require("zod");
-var PostPurchaseShadowSelectionSchema = import_zod77.z.discriminatedUnion("verdict", [
-  import_zod77.z.object({ entry: DecisionEntrySchema, verdict: import_zod77.z.literal("render") }),
-  import_zod77.z.object({ verdict: import_zod77.z.literal("skip") })
+var import_zod82 = require("zod");
+var PostPurchaseShadowSelectionSchema = import_zod82.z.discriminatedUnion("verdict", [
+  import_zod82.z.object({ entry: DecisionEntrySchema, verdict: import_zod82.z.literal("render") }),
+  import_zod82.z.object({ verdict: import_zod82.z.literal("skip") })
 ]);
-var PostPurchaseShadowReportFields = import_zod77.z.object({
-  differences: import_zod77.z.array(import_zod77.z.enum(["verdict", "entry", "targeting", "incomplete-capture", "unsupported-configuration"])).refine((differences) => new Set(differences).size === differences.length, {
+var PostPurchaseShadowReportFields = import_zod82.z.object({
+  differences: import_zod82.z.array(import_zod82.z.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: import_zod77.z.literal("shouldRender"),
-  sampleId: import_zod77.z.string(),
+  phase: import_zod82.z.literal("shouldRender"),
+  sampleId: import_zod82.z.string(),
   serverSelection: PostPurchaseShadowSelectionSchema.optional(),
-  status: import_zod77.z.enum(["match", "diverged", "incomplete"]),
-  targetingFlowIds: import_zod77.z.array(import_zod77.z.number().int().positive()),
-  workflowPhase: import_zod77.z.literal("decide")
+  status: import_zod82.z.enum(["match", "diverged", "incomplete"]),
+  targetingFlowIds: import_zod82.z.array(import_zod82.z.number().int().positive()),
+  workflowPhase: import_zod82.z.literal("decide")
 });
 var PostPurchaseShadowReportSchema = PostPurchaseShadowReportFields.refine(
   (report) => report.status !== "match" || report.differences.length === 0,
@@ -4593,20 +4760,20 @@ var PostPurchaseShadowReportSchema = PostPurchaseShadowReportFields.refine(
 });
 
 // src/schema/postPurchaseSubscriptionDisplay.ts
-var import_zod78 = require("zod");
-var Minor2 = import_zod78.z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
-var PostPurchaseSubscriptionDisplay = import_zod78.z.object({
+var import_zod83 = require("zod");
+var Minor2 = import_zod83.z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+var PostPurchaseSubscriptionDisplay = import_zod83.z.object({
   comparisonMinor: Minor2,
-  currencyCode: import_zod78.z.string().regex(/^[A-Z]{3}$/),
+  currencyCode: import_zod83.z.string().regex(/^[A-Z]{3}$/),
   priceMinor: Minor2,
   savingMinor: Minor2,
-  savingPercent: import_zod78.z.number().int().min(0).max(100)
+  savingPercent: import_zod83.z.number().int().min(0).max(100)
 });
 
 // src/schema/postPurchaseSubscriptionProduct.ts
-var import_zod79 = require("zod");
+var import_zod84 = require("zod");
 var PreparedPostPurchaseSubscription = PreparedPostPurchaseProduct.extend({
-  selection: PreparedPostPurchaseProduct.shape.selection.extend({ sellingPlanId: import_zod79.z.number().int().positive() }),
+  selection: PreparedPostPurchaseProduct.shape.selection.extend({ sellingPlanId: import_zod84.z.number().int().positive() }),
   terms: PreparedPostPurchaseProduct.shape.terms.extend({
     subscription: PostPurchaseSubscriptionTerms
   }).refine(
@@ -4619,108 +4786,108 @@ var readPostPurchaseSubscription = (prepared) => {
 };
 
 // src/schema/postPurchaseTransition.ts
-var import_zod80 = require("zod");
+var import_zod85 = require("zod");
 var OfferTransitionRequestSchema = DecideRequestSchema.extend({
   entryRevision: PostPurchaseProgressSchema.shape.entryRevision,
   progressRevision: PostPurchaseProgressSchema.shape.revision
 }).strict();
-var OfferTransitionResponseSchema = import_zod80.z.object({
-  data: import_zod80.z.object({
+var OfferTransitionResponseSchema = import_zod85.z.object({
+  data: import_zod85.z.object({
     attemptedSkips: PostPurchaseSkipTraceSchema.optional(),
     progress: PostPurchaseProgressSchema,
-    status: import_zod80.z.enum(["advanced", "no-child", "unavailable"])
+    status: import_zod85.z.enum(["advanced", "no-child", "unavailable"])
   }),
-  successful: import_zod80.z.literal(true)
+  successful: import_zod85.z.literal(true)
 });
 
 // src/schema/postPurchaseVariantDefault.ts
-var import_zod81 = require("zod");
+var import_zod86 = require("zod");
 var values = PostPurchaseVariantValues.partial().extend({
   option1: PostPurchaseVariantValues.shape.option1.nullish()
 });
 var variant = values.extend({
   id: PostPurchaseVariantId,
-  inventoryManagement: import_zod81.z.string().nullable(),
-  inventoryPolicy: import_zod81.z.string(),
-  inventoryQuantity: import_zod81.z.number()
+  inventoryManagement: import_zod86.z.string().nullable(),
+  inventoryPolicy: import_zod86.z.string(),
+  inventoryQuantity: import_zod86.z.number()
 });
-var options = import_zod81.z.array(PostPurchaseVariantOption.pick({ name: true, values: true }));
-var PostPurchaseVariantDefaultProduct = import_zod81.z.object({
+var options = import_zod86.z.array(PostPurchaseVariantOption.pick({ name: true, values: true }));
+var PostPurchaseVariantDefaultProduct = import_zod86.z.object({
   id: PostPurchaseProductId,
   options,
   selectedVariant: variant.optional(),
-  variants: import_zod81.z.array(variant)
+  variants: import_zod86.z.array(variant)
 });
 var PostPurchaseVariantDefaultSettings = PostPurchaseSettings.shape.productOptions.pick({
   hideOutOfStockVariants: true,
   matchVariant: true
 });
-var PostPurchaseOrderAttributes = import_zod81.z.record(import_zod81.z.string(), import_zod81.z.array(import_zod81.z.string())).default({});
-var PostPurchaseOriginalVariants = import_zod81.z.array(
-  import_zod81.z.object({ productId: PostPurchaseProductId, variantId: PostPurchaseVariantId })
+var PostPurchaseOrderAttributes = import_zod86.z.record(import_zod86.z.string(), import_zod86.z.array(import_zod86.z.string())).default({});
+var PostPurchaseOriginalVariants = import_zod86.z.array(
+  import_zod86.z.object({ productId: PostPurchaseProductId, variantId: PostPurchaseVariantId })
 );
-var PostPurchaseAttributeProducts = import_zod81.z.array(
-  import_zod81.z.object({ id: PostPurchaseProductId, options, variants: import_zod81.z.array(values.extend({ id: PostPurchaseVariantId })) })
+var PostPurchaseAttributeProducts = import_zod86.z.array(
+  import_zod86.z.object({ id: PostPurchaseProductId, options, variants: import_zod86.z.array(values.extend({ id: PostPurchaseVariantId })) })
 );
 
 // src/schema/postPurchaseVariantDefaultContext.ts
-var import_zod82 = require("zod");
-var PostPurchaseVariantDefaultContext = import_zod82.z.object({
-  enrichedLineItems: import_zod82.z.unknown().optional(),
+var import_zod87 = require("zod");
+var PostPurchaseVariantDefaultContext = import_zod87.z.object({
+  enrichedLineItems: import_zod87.z.unknown().optional(),
   originalVariants: PostPurchaseOriginalVariants
 });
 
 // src/schema/shopConfig.ts
-var import_zod83 = require("zod");
-var ShopConfig = import_zod83.z.object({
-  activeExperiments: import_zod83.z.array(
-    import_zod83.z.object({
-      data: import_zod83.z.array(
-        import_zod83.z.object({
-          aliasName: import_zod83.z.string(),
-          cssInput: import_zod83.z.string().nullish(),
-          elementId: import_zod83.z.coerce.number(),
-          id: import_zod83.z.coerce.number(),
-          javascriptInput: import_zod83.z.string().nullish(),
-          traffic: import_zod83.z.coerce.number()
+var import_zod88 = require("zod");
+var ShopConfig = import_zod88.z.object({
+  activeExperiments: import_zod88.z.array(
+    import_zod88.z.object({
+      data: import_zod88.z.array(
+        import_zod88.z.object({
+          aliasName: import_zod88.z.string(),
+          cssInput: import_zod88.z.string().nullish(),
+          elementId: import_zod88.z.coerce.number(),
+          id: import_zod88.z.coerce.number(),
+          javascriptInput: import_zod88.z.string().nullish(),
+          traffic: import_zod88.z.coerce.number()
         })
       ),
-      id: import_zod83.z.coerce.number(),
-      name: import_zod83.z.string(),
-      pageTarget: import_zod83.z.string().nullable(),
-      pageTargetUrl: import_zod83.z.string().nullable(),
-      placeholderId: import_zod83.z.coerce.number().nullable(),
-      type: import_zod83.z.string()
+      id: import_zod88.z.coerce.number(),
+      name: import_zod88.z.string(),
+      pageTarget: import_zod88.z.string().nullable(),
+      pageTargetUrl: import_zod88.z.string().nullable(),
+      placeholderId: import_zod88.z.coerce.number().nullable(),
+      type: import_zod88.z.string()
     })
   ),
-  activePackages: import_zod83.z.array(
-    import_zod83.z.object({
-      cancelledAt: import_zod83.z.string().nullable(),
-      id: import_zod83.z.number(),
-      installedAt: import_zod83.z.string().nullable(),
-      isActive: import_zod83.z.boolean(),
-      isBillable: import_zod83.z.boolean(),
-      packageId: import_zod83.z.number(),
-      packageName: import_zod83.z.string(),
-      shortName: import_zod83.z.string(),
-      trialDays: import_zod83.z.number(),
-      uninstalledAt: import_zod83.z.string().nullable()
+  activePackages: import_zod88.z.array(
+    import_zod88.z.object({
+      cancelledAt: import_zod88.z.string().nullable(),
+      id: import_zod88.z.number(),
+      installedAt: import_zod88.z.string().nullable(),
+      isActive: import_zod88.z.boolean(),
+      isBillable: import_zod88.z.boolean(),
+      packageId: import_zod88.z.number(),
+      packageName: import_zod88.z.string(),
+      shortName: import_zod88.z.string(),
+      trialDays: import_zod88.z.number(),
+      uninstalledAt: import_zod88.z.string().nullable()
     })
   ),
-  apiKey: import_zod83.z.string(),
-  billingVersion: import_zod83.z.string().nullable(),
-  cacheKey: import_zod83.z.coerce.number(),
-  carousel: import_zod83.z.enum(["flickity", "splide"]),
-  currency: import_zod83.z.string(),
-  currencySymbol: import_zod83.z.string(),
-  domain: import_zod83.z.string(),
-  enabledJquery: import_zod83.z.boolean(),
-  enabledPresentmentCurrencies: import_zod83.z.array(import_zod83.z.string()),
-  hasSmartCollectionsEnabled: import_zod83.z.boolean(),
-  hasSmartSearchEnabled: import_zod83.z.boolean(),
-  id: import_zod83.z.coerce.number(),
-  integrations: import_zod83.z.record(
-    import_zod83.z.enum([
+  apiKey: import_zod88.z.string(),
+  billingVersion: import_zod88.z.string().nullable(),
+  cacheKey: import_zod88.z.coerce.number(),
+  carousel: import_zod88.z.enum(["flickity", "splide"]),
+  currency: import_zod88.z.string(),
+  currencySymbol: import_zod88.z.string(),
+  domain: import_zod88.z.string(),
+  enabledJquery: import_zod88.z.boolean(),
+  enabledPresentmentCurrencies: import_zod88.z.array(import_zod88.z.string()),
+  hasSmartCollectionsEnabled: import_zod88.z.boolean(),
+  hasSmartSearchEnabled: import_zod88.z.boolean(),
+  id: import_zod88.z.coerce.number(),
+  integrations: import_zod88.z.record(
+    import_zod88.z.enum([
       "attentive",
       "judgeme",
       "junip",
@@ -4733,170 +4900,170 @@ var ShopConfig = import_zod83.z.object({
       "stamped",
       "yotpo"
     ]),
-    import_zod83.z.union([import_zod83.z.boolean(), import_zod83.z.unknown()])
+    import_zod88.z.union([import_zod88.z.boolean(), import_zod88.z.unknown()])
   ),
-  markets: import_zod83.z.object({
-    enabled: import_zod83.z.boolean()
+  markets: import_zod88.z.object({
+    enabled: import_zod88.z.boolean()
   }),
-  monetize: import_zod83.z.object({
-    publisherKey: import_zod83.z.string().nullable()
+  monetize: import_zod88.z.object({
+    publisherKey: import_zod88.z.string().nullable()
   }).nullish(),
-  moneyFormat: import_zod83.z.string(),
-  myshopifyDomain: import_zod83.z.string(),
-  primaryLocale: import_zod83.z.string(),
-  productGroupsEnabled: import_zod83.z.enum(["no", "yes"]).transform((value) => value === "yes"),
-  rechargeCustomDomain: import_zod83.z.string().nullable(),
-  sellingPlansEnabled: import_zod83.z.boolean(),
-  shopId: import_zod83.z.number(),
-  shopifySellingPlansEnabled: import_zod83.z.boolean(),
-  shopName: import_zod83.z.string(),
-  storefrontAccessToken: import_zod83.z.string().nullable(),
-  useRebuyIcons: import_zod83.z.boolean()
+  moneyFormat: import_zod88.z.string(),
+  myshopifyDomain: import_zod88.z.string(),
+  primaryLocale: import_zod88.z.string(),
+  productGroupsEnabled: import_zod88.z.enum(["no", "yes"]).transform((value) => value === "yes"),
+  rechargeCustomDomain: import_zod88.z.string().nullable(),
+  sellingPlansEnabled: import_zod88.z.boolean(),
+  shopId: import_zod88.z.number(),
+  shopifySellingPlansEnabled: import_zod88.z.boolean(),
+  shopName: import_zod88.z.string(),
+  storefrontAccessToken: import_zod88.z.string().nullable(),
+  useRebuyIcons: import_zod88.z.boolean()
 });
 
 // src/schema/userConfig.ts
-var import_zod84 = require("zod");
-var UserConfig = import_zod84.z.object({
+var import_zod89 = require("zod");
+var UserConfig = import_zod89.z.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: import_zod84.z.array(import_zod84.z.unknown())
+  smartFlows: import_zod89.z.array(import_zod89.z.unknown())
 });
 
 // src/schema/widgetData.ts
-var import_zod93 = require("zod");
+var import_zod98 = require("zod");
 
 // src/schema/widgets/abTestingPlaceholder.ts
-var import_zod85 = require("zod");
-var ABTestingPlaceholder = import_zod85.z.looseObject({
-  type: import_zod85.z.literal("placeholder")
+var import_zod90 = require("zod");
+var ABTestingPlaceholder = import_zod90.z.looseObject({
+  type: import_zod90.z.literal("placeholder")
 });
 
 // src/schema/widgets/checkoutExtension.ts
-var import_zod86 = require("zod");
-var CheckoutExtension = import_zod86.z.looseObject({
-  type: import_zod86.z.literal(WidgetType.shopify_checkout_extension).default(WidgetType.shopify_checkout_extension)
+var import_zod91 = require("zod");
+var CheckoutExtension = import_zod91.z.looseObject({
+  type: import_zod91.z.literal(WidgetType.shopify_checkout_extension).default(WidgetType.shopify_checkout_extension)
 });
 
 // src/schema/widgets/contentBlock.ts
-var import_zod87 = require("zod");
-var ContentBlockV1 = import_zod87.z.object({
-  blockSpacing: import_zod87.z.enum(spacings).optional(),
-  imageBlocks: import_zod87.z.union([
-    import_zod87.z.array(
-      import_zod87.z.object({
-        altText: import_zod87.z.string().nullable(),
-        description: import_zod87.z.string().nullable(),
-        id: import_zod87.z.uuid(),
-        imagePlacement: import_zod87.z.enum(["top", "right", "bottom", "left"]),
-        imageSize: import_zod87.z.number(),
-        imageUrl: import_zod87.z.url(),
-        textAlignment: import_zod87.z.enum(["left", "center", "right"]),
+var import_zod92 = require("zod");
+var ContentBlockV1 = import_zod92.z.object({
+  blockSpacing: import_zod92.z.enum(spacings).optional(),
+  imageBlocks: import_zod92.z.union([
+    import_zod92.z.array(
+      import_zod92.z.object({
+        altText: import_zod92.z.string().nullable(),
+        description: import_zod92.z.string().nullable(),
+        id: import_zod92.z.uuid(),
+        imagePlacement: import_zod92.z.enum(["top", "right", "bottom", "left"]),
+        imageSize: import_zod92.z.number(),
+        imageUrl: import_zod92.z.url(),
+        textAlignment: import_zod92.z.enum(["left", "center", "right"]),
         /** Inline scale only: an image caption can never be a block-level heading. */
-        textSize: import_zod87.z.enum(inlineTextSizeNames)
+        textSize: import_zod92.z.enum(inlineTextSizeNames)
       })
     ),
-    import_zod87.z.strictObject({}).transform(() => [])
+    import_zod92.z.strictObject({}).transform(() => [])
   ]).optional(),
-  imageLayout: import_zod87.z.enum(["row", "column"]).optional(),
-  language: import_zod87.z.object({
-    description: import_zod87.z.string(),
-    superTitle: import_zod87.z.string(),
-    title: import_zod87.z.string()
+  imageLayout: import_zod92.z.enum(["row", "column"]).optional(),
+  language: import_zod92.z.object({
+    description: import_zod92.z.string(),
+    superTitle: import_zod92.z.string(),
+    title: import_zod92.z.string()
   }),
-  previewMode: import_zod87.z.boolean(),
-  type: import_zod87.z.literal(WidgetType.ui_extension_content_block).default(WidgetType.ui_extension_content_block),
-  version: import_zod87.z.literal(1)
+  previewMode: import_zod92.z.boolean(),
+  type: import_zod92.z.literal(WidgetType.ui_extension_content_block).default(WidgetType.ui_extension_content_block),
+  version: import_zod92.z.literal(1)
 });
-var ContentBlock = import_zod87.z.discriminatedUnion("version", [
+var ContentBlock = import_zod92.z.discriminatedUnion("version", [
   ContentBlockV1,
   CABRootSection.extend({
-    type: import_zod87.z.literal(WidgetType.ui_extension_content_block).default(WidgetType.ui_extension_content_block)
+    type: import_zod92.z.literal(WidgetType.ui_extension_content_block).default(WidgetType.ui_extension_content_block)
   })
 ]);
 
 // src/schema/widgets/giftWithPurchase.ts
-var import_zod88 = require("zod");
-var GiftWithPurchase = import_zod88.z.looseObject({
-  type: import_zod88.z.literal(WidgetType.gift_with_purchase).default(WidgetType.gift_with_purchase)
+var import_zod93 = require("zod");
+var GiftWithPurchase = import_zod93.z.looseObject({
+  type: import_zod93.z.literal(WidgetType.gift_with_purchase).default(WidgetType.gift_with_purchase)
 });
 
 // src/schema/widgets/lineItemEditor.ts
-var import_zod89 = require("zod");
-var LineItemEditorSwitchLanguageV1 = import_zod89.z.object({
-  downgradeToOneTimeLabel: import_zod89.z.string().optional(),
+var import_zod94 = require("zod");
+var LineItemEditorSwitchLanguageV1 = import_zod94.z.object({
+  downgradeToOneTimeLabel: import_zod94.z.string().optional(),
   /** Frequency-option template (`{{frequency}}`/`{{interval}}`) for the plan select. */
-  subscriptionOptionLabel: import_zod89.z.string().optional(),
-  upgradeToSubscriptionLabel: import_zod89.z.string().optional(),
-  upgradeToSubscriptionWithoutDiscountLabel: import_zod89.z.string().optional()
+  subscriptionOptionLabel: import_zod94.z.string().optional(),
+  upgradeToSubscriptionLabel: import_zod94.z.string().optional(),
+  upgradeToSubscriptionWithoutDiscountLabel: import_zod94.z.string().optional()
 });
-var LineItemEditorV1 = import_zod89.z.object({
+var LineItemEditorV1 = import_zod94.z.object({
   /** Legacy `getStyles` button style; the converter carries a valid kind, defaulting to `plain`. */
-  button: import_zod89.z.object({ kind: import_zod89.z.enum(["plain", "primary", "secondary"]).optional() }).optional(),
-  previewMode: import_zod89.z.boolean().optional(),
-  switchToSubscription: import_zod89.z.object({
-    disableDowngrade: import_zod89.z.boolean().optional(),
+  button: import_zod94.z.object({ kind: import_zod94.z.enum(["plain", "primary", "secondary"]).optional() }).optional(),
+  previewMode: import_zod94.z.boolean().optional(),
+  switchToSubscription: import_zod94.z.object({
+    disableDowngrade: import_zod94.z.boolean().optional(),
     language: LineItemEditorSwitchLanguageV1.optional()
   }).optional(),
-  switchToSubscriptionEnabled: import_zod89.z.boolean().optional(),
-  tracking: import_zod89.z.object({
-    enableAttribution: import_zod89.z.boolean().optional(),
-    enableSource: import_zod89.z.boolean().optional(),
-    enableWidget: import_zod89.z.boolean().optional()
+  switchToSubscriptionEnabled: import_zod94.z.boolean().optional(),
+  tracking: import_zod94.z.object({
+    enableAttribution: import_zod94.z.boolean().optional(),
+    enableSource: import_zod94.z.boolean().optional(),
+    enableWidget: import_zod94.z.boolean().optional()
   }).optional(),
-  type: import_zod89.z.literal(WidgetType.ui_extension_line_item_editor).default(WidgetType.ui_extension_line_item_editor),
-  version: import_zod89.z.literal(1)
+  type: import_zod94.z.literal(WidgetType.ui_extension_line_item_editor).default(WidgetType.ui_extension_line_item_editor),
+  version: import_zod94.z.literal(1)
 });
-var LineItemEditor = import_zod89.z.discriminatedUnion("version", [
+var LineItemEditor = import_zod94.z.discriminatedUnion("version", [
   LineItemEditorV1,
   CABRootSection.extend({
-    type: import_zod89.z.literal(WidgetType.ui_extension_line_item_editor).default(WidgetType.ui_extension_line_item_editor)
+    type: import_zod94.z.literal(WidgetType.ui_extension_line_item_editor).default(WidgetType.ui_extension_line_item_editor)
   })
 ]);
 
 // src/schema/widgets/progressBar.ts
-var import_zod90 = require("zod");
-var ProgressBar = import_zod90.z.looseObject({
-  type: import_zod90.z.literal(WidgetType.ui_extension_progress_bar).default(WidgetType.ui_extension_progress_bar)
+var import_zod95 = require("zod");
+var ProgressBar = import_zod95.z.looseObject({
+  type: import_zod95.z.literal(WidgetType.ui_extension_progress_bar).default(WidgetType.ui_extension_progress_bar)
 });
 
 // src/schema/widgets/rebuyButton.ts
-var import_zod91 = require("zod");
-var RebuyButtonV1 = import_zod91.z.looseObject({
-  type: import_zod91.z.literal(WidgetType.ui_extension_button).default(WidgetType.ui_extension_button),
-  version: import_zod91.z.literal(1)
+var import_zod96 = require("zod");
+var RebuyButtonV1 = import_zod96.z.looseObject({
+  type: import_zod96.z.literal(WidgetType.ui_extension_button).default(WidgetType.ui_extension_button),
+  version: import_zod96.z.literal(1)
 });
-var RebuyButton = import_zod91.z.discriminatedUnion("version", [
+var RebuyButton = import_zod96.z.discriminatedUnion("version", [
   RebuyButtonV1,
   CABRootSection.extend({
-    type: import_zod91.z.literal(WidgetType.ui_extension_button).default(WidgetType.ui_extension_button)
+    type: import_zod96.z.literal(WidgetType.ui_extension_button).default(WidgetType.ui_extension_button)
   })
 ]);
 
 // src/schema/widgets/rebuyMonetize.ts
-var import_zod92 = require("zod");
-var RebuyMonetize = import_zod92.z.looseObject({
-  type: import_zod92.z.literal(WidgetType.ui_extension_ad).default(WidgetType.ui_extension_ad)
+var import_zod97 = require("zod");
+var RebuyMonetize = import_zod97.z.looseObject({
+  type: import_zod97.z.literal(WidgetType.ui_extension_ad).default(WidgetType.ui_extension_ad)
 });
-var RebuyMonetizeV1 = import_zod92.z.object({
-  name: import_zod92.z.string().nullable().optional(),
-  previewMode: import_zod92.z.boolean().optional(),
+var RebuyMonetizeV1 = import_zod97.z.object({
+  name: import_zod97.z.string().nullable().optional(),
+  previewMode: import_zod97.z.boolean().optional(),
   /** Privacy Policy footer href → the marker section's `privacyPolicyUrl`. */
-  privacyPolicyUrl: import_zod92.z.string().nullable().optional(),
+  privacyPolicyUrl: import_zod97.z.string().nullable().optional(),
   /** Ads-taxonomy sub-vertical id — one of the admin Monetize editor's two configurables. */
-  subVertical: import_zod92.z.string().nullable().optional(),
-  tracking: import_zod92.z.object({
-    enableAttribution: import_zod92.z.boolean().optional(),
-    enableSource: import_zod92.z.boolean().optional(),
-    enableWidget: import_zod92.z.boolean().optional()
+  subVertical: import_zod97.z.string().nullable().optional(),
+  tracking: import_zod97.z.object({
+    enableAttribution: import_zod97.z.boolean().optional(),
+    enableSource: import_zod97.z.boolean().optional(),
+    enableWidget: import_zod97.z.boolean().optional()
   }).optional(),
-  type: import_zod92.z.literal(WidgetType.ui_extension_ad).default(WidgetType.ui_extension_ad),
-  version: import_zod92.z.literal(1),
+  type: import_zod97.z.literal(WidgetType.ui_extension_ad).default(WidgetType.ui_extension_ad),
+  version: import_zod97.z.literal(1),
   /** Ads-taxonomy vertical id — one of the admin Monetize editor's two configurables. */
-  vertical: import_zod92.z.string().nullable().optional()
+  vertical: import_zod97.z.string().nullable().optional()
 });
 
 // src/schema/widgetData.ts
@@ -4910,7 +5077,7 @@ var extensionWidgetTypes = [
   WidgetType.ui_extension_line_item_editor,
   WidgetType.ui_extension_progress_bar
 ];
-var WidgetData = import_zod93.z.discriminatedUnion("type", [
+var WidgetData = import_zod98.z.discriminatedUnion("type", [
   ABTestingPlaceholder,
   CheckoutExtension,
   ContentBlock,
@@ -5270,36 +5437,36 @@ var SWITCH_LABELS = {
 };
 
 // src/schema/widgets/post-purchase-offer/postPurchaseOffer.ts
-var import_zod95 = require("zod");
+var import_zod100 = require("zod");
 
 // src/schema/widgets/post-purchase-offer/postPurchaseWidget.ts
-var import_zod94 = require("zod");
-var PostPurchaseWidgetLinkedFlow = import_zod94.z.object({
-  id: import_zod94.z.number(),
-  name: import_zod94.z.string()
-});
-var PostPurchaseWidget = import_zod94.z.object({
-  classification: import_zod94.z.literal("post_purchase_offer_page").default("post_purchase_offer_page"),
-  createdAtTime: import_zod94.z.iso.datetime({ offset: true }).optional(),
-  customEndpointName: import_zod94.z.string().nullish(),
-  id: import_zod94.z.number().default(0),
-  lastViewed: import_zod94.z.iso.datetime({ offset: true }).nullish(),
-  linkedCustomEndpointId: import_zod94.z.number().nullish(),
-  linkedFlows: import_zod94.z.array(PostPurchaseWidgetLinkedFlow).optional(),
-  name: import_zod94.z.string().default(""),
-  owner: import_zod94.z.number().nullish(),
+var import_zod99 = require("zod");
+var PostPurchaseWidgetLinkedFlow = import_zod99.z.object({
+  id: import_zod99.z.number(),
+  name: import_zod99.z.string()
+});
+var PostPurchaseWidget = import_zod99.z.object({
+  classification: import_zod99.z.literal("post_purchase_offer_page").default("post_purchase_offer_page"),
+  createdAtTime: import_zod99.z.iso.datetime({ offset: true }).optional(),
+  customEndpointName: import_zod99.z.string().nullish(),
+  id: import_zod99.z.number().default(0),
+  lastViewed: import_zod99.z.iso.datetime({ offset: true }).nullish(),
+  linkedCustomEndpointId: import_zod99.z.number().nullish(),
+  linkedFlows: import_zod99.z.array(PostPurchaseWidgetLinkedFlow).optional(),
+  name: import_zod99.z.string().default(""),
+  owner: import_zod99.z.number().nullish(),
   settings: PostPurchaseSettings
 });
 
 // src/schema/widgets/post-purchase-offer/postPurchaseOffer.ts
-var PostPurchaseOffer = import_zod95.z.discriminatedUnion("successful", [
-  import_zod95.z.strictObject({
-    errors: import_zod95.z.array(import_zod95.z.object({ message: import_zod95.z.string() })),
-    message: import_zod95.z.string(),
-    successful: import_zod95.z.literal(false)
+var PostPurchaseOffer = import_zod100.z.discriminatedUnion("successful", [
+  import_zod100.z.strictObject({
+    errors: import_zod100.z.array(import_zod100.z.object({ message: import_zod100.z.string() })),
+    message: import_zod100.z.string(),
+    successful: import_zod100.z.literal(false)
   }),
-  import_zod95.z.strictObject({
-    successful: import_zod95.z.literal(true),
+  import_zod100.z.strictObject({
+    successful: import_zod100.z.literal(true),
     widget: PostPurchaseWidget
   })
 ]);