@rebuy/rebuy 3.32.0 → 3.34.0

package/dist/server/index.cjs

@@ -44,6 +44,7 @@ __export(server_exports, {
   fetchMonetizeOffers: () => fetchMonetizeOffers,
   fetchUserConfig: () => fetchUserConfig,
   postAnalyticsEvents: () => postAnalyticsEvents,
+  preparePostPurchaseSubscription: () => preparePostPurchaseSubscription,
   translateAnalyticsEvent: () => translateAnalyticsEvent,
   validateGifts: () => validateGifts
 });
@@ -2264,10 +2265,10 @@ var HEADER_PARAGRAPH_STYLES = {
   superTitle: { color: "base", fontSize: "extraLarge", marks: [{ type: "bold" }] },
   title: { color: "base", fontSize: "medium", marks: [{ type: "bold" }] }
 };
-var convertContentBlockTextToV2 = (language, text2 = literalText, textAlign = "center") => {
-  const description = language?.description;
-  const superTitle = language?.superTitle;
-  const title = language?.title;
+var convertContentBlockTextToV2 = (language2, text2 = literalText, textAlign = "center") => {
+  const description = language2?.description;
+  const superTitle = language2?.superTitle;
+  const title = language2?.title;
   return TiptapDocument.parse({
     attrs: { blockSpacing: "tight" },
     content: [
@@ -2379,7 +2380,7 @@ var LOCATION_TO_EDITOR_MODE = {
 };
 
 // src/transforms/contentBlockV1/convertContentBlockToV2.ts
-var hasText = (language) => !!language && !!(language.description || language.superTitle || language.title);
+var hasText = (language2) => !!language2 && !!(language2.description || language2.superTitle || language2.title);
 var convertContentBlockToV2 = ({ id, settings }) => {
   const imageBlocks = settings.imageBlocks ?? [];
   return CABRootSection.parse({
@@ -3422,7 +3423,7 @@ var buildQuantity = (settings) => {
 };
 var buildSubscriptionButton = (settings) => {
   if (settings.productType !== "both" && settings.productType !== "subscription") return [];
-  const language = settings.language;
+  const language2 = settings.language;
   const slot = (buttonField, override) => ({
     buttonField,
     content: localizedContent(SWITCH_LABELS[buttonField], override, SWITCH_LABEL_TOKENS2),
@@ -3436,9 +3437,9 @@ var buildSubscriptionButton = (settings) => {
       ...settings.productType === "subscription" && { disableDowngrade: true },
       sections: [
         slot("subscriptionOption", void 0),
-        slot("switchToOneTimePurchase", language?.cartSwitchToOnetime),
-        slot("switchToSubscriptionNoDiscount", language?.upgradeToSubscription),
-        slot("switchToSubscriptionWithDiscount", language?.upgradeToSubscription)
+        slot("switchToOneTimePurchase", language2?.cartSwitchToOnetime),
+        slot("switchToSubscriptionNoDiscount", language2?.upgradeToSubscription),
+        slot("switchToSubscriptionWithDiscount", language2?.upgradeToSubscription)
       ],
       sectionType: "button"
     }
@@ -3494,10 +3495,10 @@ var buildOfferCard = (settings, horizontal) => {
   const reviews = buildReviews(settings);
   const variants = buildVariants(settings);
   const quantity = buildQuantity(settings);
-  const subscription = buildSubscriptionButton(settings);
+  const subscription2 = buildSubscriptionButton(settings);
   const reveal = buildRevealButton(settings);
   const addButton = buildAddButton(settings);
-  const controls = [...description, ...quantity, ...variants, ...subscription];
+  const controls = [...description, ...quantity, ...variants, ...subscription2];
   const info = detailBlock([title, ...variantTitle, ...reviews, price], horizontal, variantTitle.length > 0);
   const card = (sections) => [
     {
@@ -3551,9 +3552,9 @@ var buildCarouselNav = () => ({
   sectionType: "layout"
 });
 var HEADER_FIELDS = ["superTitle", "title", "description"];
-var sanitizedHeader = (language) => Object.fromEntries(
+var sanitizedHeader = (language2) => Object.fromEntries(
   HEADER_FIELDS.flatMap((field) => {
-    const value = language?.[field];
+    const value = language2?.[field];
     const sanitized = value ? stripContentBlockHtml(normalizeTokens(value)) : "";
     return sanitized ? [[field, sanitized]] : [];
   })
@@ -3650,7 +3651,7 @@ var coerceIntegrations = (integrations) => Object.fromEntries(
     return [key, value];
   })
 );
-var buildBanner = (language) => language?.successBannerEnabled ? [
+var buildBanner = (language2) => language2?.successBannerEnabled ? [
   {
     /**
      * The banner-level tag is the extraction/routing key on BOTH renderers (React CAB's
@@ -3663,7 +3664,7 @@ var buildBanner = (language) => language?.successBannerEnabled ? [
     dismissible: true,
     sections: [
       {
-        content: bannerMessageContent(language.successBannerMessageRte),
+        content: bannerMessageContent(language2.successBannerMessageRte),
         sectionType: "text"
       },
       {
@@ -4497,8 +4498,8 @@ var tierLabel = (tier) => {
 };
 var discountOf = (tier) => {
   if (tier.type !== "discount") return void 0;
-  const amount = tier.discountAmountFromTotal ?? 0;
-  return tier.discountType === "fixedAmount" ? { amount: Math.round(amount * 100), type: "fixedAmount" } : { amount, type: "percentage" };
+  const amount2 = tier.discountAmountFromTotal ?? 0;
+  return tier.discountType === "fixedAmount" ? { amount: Math.round(amount2 * 100), type: "fixedAmount" } : { amount: amount2, type: "percentage" };
 };
 var iconSizeOf = (tier) => {
   const px = Math.round(Number.parseFloat(String(tier.productTierElementSize ?? "")));
@@ -5502,6 +5503,689 @@ var validateGifts = async (input, ctx) => {
   return { adjust: [...targets].map(([lineId, quantity]) => ({ lineId, quantity })), remove: [...removed] };
 };
 
+// src/server/normalizePostPurchaseProduct.ts
+var import_compat6 = require("es-toolkit/compat");
+var import_zod43 = require("zod");
+
+// src/schema/postPurchaseProductSettings.ts
+var import_zod42 = require("zod");
+
+// src/schema/postPurchaseProductSource.ts
+var import_zod39 = require("zod");
+var PostPurchaseAmount = import_zod39.z.string().regex(/^\d+(?:\.\d+)?$/).refine((value) => Number.isFinite(Number(value)));
+var PostPurchaseProductId = import_zod39.z.number().int().positive();
+var PostPurchaseVariantId = import_zod39.z.number().int().positive();
+var ProductBase = OfferProduct.pick({ description: true, id: true, image: true, title: true }).extend({
+  description: OfferProduct.shape.description.nullable(),
+  id: PostPurchaseProductId
+});
+var SourceVariant = OfferProduct.shape.variants.element.pick({ id: true, title: true }).extend({
+  compareAtPrice: PostPurchaseAmount.nullable(),
+  id: PostPurchaseVariantId,
+  imageId: import_zod39.z.number().int().nonnegative().nullish(),
+  inventoryManagement: import_zod39.z.string().nullable(),
+  inventoryPolicy: import_zod39.z.string(),
+  inventoryQuantity: import_zod39.z.number(),
+  option1: import_zod39.z.unknown().optional(),
+  option2: import_zod39.z.unknown().optional(),
+  option3: import_zod39.z.unknown().optional(),
+  price: PostPurchaseAmount,
+  productId: PostPurchaseProductId,
+  sellingPlanAllocations: import_zod39.z.unknown().optional()
+});
+var Product2 = ProductBase.extend({
+  images: import_zod39.z.array(
+    import_zod39.z.object({ alt: import_zod39.z.string().optional().catch(void 0), id: import_zod39.z.number().int().positive(), src: import_zod39.z.string() })
+  ).nullish(),
+  metadata: import_zod39.z.object({
+    productQuantity: import_zod39.z.union([
+      import_zod39.z.number().int().positive(),
+      import_zod39.z.string().regex(/^[1-9]\d*$/).transform(Number)
+    ]).optional()
+  }).optional(),
+  metafields: import_zod39.z.unknown().optional(),
+  options: import_zod39.z.unknown().optional(),
+  productGroupVariants: import_zod39.z.array(import_zod39.z.unknown()).default([]),
+  selectedVariant: import_zod39.z.unknown().optional(),
+  sellingPlanGroups: import_zod39.z.array(
+    OfferProduct.shape.sellingPlanGroups.unwrap().element.extend({
+      discountAmount: import_zod39.z.unknown().optional(),
+      discountType: import_zod39.z.unknown().optional(),
+      id: import_zod39.z.unknown().optional(),
+      requiresSellingPlan: import_zod39.z.boolean().default(false),
+      sellingPlans: import_zod39.z.unknown().optional()
+    })
+  ).default([]),
+  variants: import_zod39.z.array(SourceVariant)
+});
+var PostPurchaseProductSource = import_zod39.z.object({
+  data: import_zod39.z.array(Product2),
+  metadata: import_zod39.z.object({ widget: import_zod39.z.record(import_zod39.z.string(), import_zod39.z.unknown()).default({}) }).default({ widget: {} })
+});
+
+// src/schema/widgets/post-purchase-offer/postPurchaseSettings.ts
+var import_zod41 = require("zod");
+
+// src/schema/widgets/post-purchase-offer/common.ts
+var import_compat5 = require("es-toolkit/compat");
+var import_zod40 = require("zod");
+var strictNumber = import_zod40.z.union([
+  import_zod40.z.number(),
+  import_zod40.z.string().transform((value) => (0, import_compat5.toNumber)((0, import_compat5.replace)((0, import_compat5.toString)(value), /[^0-9.]/g, "")) || 0),
+  import_zod40.z.unknown().transform(() => 0)
+]);
+
+// src/schema/widgets/post-purchase-offer/postPurchaseSettings.ts
+var PostPurchaseSettings = import_zod41.z.object({
+  advance: import_zod41.z.object({ removePartialOrder: import_zod41.z.boolean().default(true) }).optional().default(() => ({ removePartialOrder: true })),
+  blocks: import_zod41.z.union([import_zod41.z.array(PostPurchaseBlock), import_zod41.z.unknown().transform(() => [])]).default(() => [
+    PostPurchaseBlock.parse({ settings: {}, styles: {}, type: BlockType.timer }),
+    PostPurchaseBlock.parse({ settings: {}, styles: {}, type: BlockType.callout_banner }),
+    PostPurchaseBlock.parse({ type: BlockType.product_information })
+  ]),
+  columnLayout: import_zod41.z.boolean().optional(),
+  discount: import_zod41.z.object({
+    amount: strictNumber.default(30),
+    shouldShowSavingText: import_zod41.z.boolean().optional().default(true),
+    type: import_zod41.z.enum(["none", "fixed_amount", "percentage"]).default("none")
+  }),
+  discountedFrom: import_zod41.z.enum(["price", "compare_at_price"]).optional().default("price"),
+  endpoint: import_zod41.z.string().optional(),
+  integrations: import_zod41.z.object({
+    judgeme: import_zod41.z.boolean().default(false),
+    junip: import_zod41.z.boolean().optional().default(false),
+    klaviyo: import_zod41.z.boolean().default(false),
+    loox: import_zod41.z.boolean().default(false),
+    okendo: import_zod41.z.boolean().default(false),
+    opinew: import_zod41.z.boolean().optional().default(false),
+    reviewsio: import_zod41.z.boolean().optional().default(false),
+    stamped: import_zod41.z.boolean().default(false),
+    yotpo: import_zod41.z.boolean().default(false)
+  }),
+  key: import_zod41.z.string().optional(),
+  language: import_zod41.z.object({
+    description: import_zod41.z.union([import_zod41.z.string(), import_zod41.z.unknown().transform(() => "")]).default(""),
+    descriptionEnabled: import_zod41.z.boolean().optional().default(false),
+    descriptionRte: import_zod41.z.object({
+      content: import_zod41.z.array(import_zod41.z.unknown()),
+      type: import_zod41.z.string()
+    }).optional(),
+    descriptionSpacing: import_zod41.z.enum(["none", "xtight", "tight", "default", "loose", "xloose"]).optional(),
+    displayCtaPrice: import_zod41.z.boolean().default(true),
+    global: import_zod41.z.object({
+      declineAll: import_zod41.z.string().optional().default("Decline All"),
+      declineThisOffer: import_zod41.z.string().default("Decline this offer"),
+      free: import_zod41.z.string().optional().default("Free"),
+      notAvailable: import_zod41.z.string().optional().default("Not available"),
+      payNow: import_zod41.z.string().default("Pay Now"),
+      payNowUpgradeToSubscription: import_zod41.z.string().optional().default("Upgrade to Subscription"),
+      quantity: import_zod41.z.string().default("Quantity"),
+      /** This isn't configurable in the admin-nextjs editor */
+      recurringShipping: import_zod41.z.string().optional().default("Recurring shipping"),
+      recurringSubtotal: import_zod41.z.string().default("Recurring subtotal"),
+      reviewsPlural: import_zod41.z.string().optional().default("Reviews"),
+      reviewsSingular: import_zod41.z.string().optional().default("Review"),
+      save: import_zod41.z.union([import_zod41.z.string(), import_zod41.z.unknown().transform(() => "Save")]).optional().default("Save"),
+      shipping: import_zod41.z.string().default("Shipping"),
+      subscriptionOption: import_zod41.z.string().optional().default("Subscribe and Save"),
+      subtotal: import_zod41.z.string().default("Subtotal"),
+      taxes: import_zod41.z.string().default("Taxes"),
+      total: import_zod41.z.string().default("Total")
+    }).optional().default(() => ({
+      declineAll: "Decline All",
+      declineThisOffer: "Decline this offer",
+      free: "Free",
+      notAvailable: "Not available",
+      payNow: "Pay Now",
+      payNowUpgradeToSubscription: "Upgrade to Subscription",
+      quantity: "Quantity",
+      /** This isn't configurable in the admin-nextjs editor */
+      recurringShipping: "Recurring shipping",
+      recurringSubtotal: "Recurring subtotal",
+      reviewsPlural: "Reviews",
+      reviewsSingular: "Review",
+      save: "Save",
+      shipping: "Shipping",
+      subscriptionOption: "Subscribe and Save",
+      subtotal: "Subtotal",
+      taxes: "Taxes",
+      total: "Total"
+    })),
+    globalTranslation: import_zod41.z.string().optional().default("english")
+  }),
+  metafields: import_zod41.z.boolean().default(false),
+  /** This isn't configurable in the admin-nextjs editor */
+  offer: import_zod41.z.object({
+    count: import_zod41.z.number().default(1)
+  }),
+  offersLayout: import_zod41.z.object({
+    itemsPerPage: import_zod41.z.number().optional(),
+    type: import_zod41.z.enum(["list", "grid", "carousel"]).default("list")
+  }).optional().default({
+    type: "list"
+  }),
+  /** This isn't configurable in the admin-nextjs editor */
+  previewMode: import_zod41.z.boolean().default(false),
+  productLimit: import_zod41.z.number().optional().default(1),
+  productOptions: import_zod41.z.object({
+    /** This isn't configurable in the admin-nextjs editor */
+    hideOutOfStockVariants: import_zod41.z.boolean().optional().default(false),
+    matchVariant: import_zod41.z.boolean().optional().default(true),
+    showDeclineAll: import_zod41.z.enum(["above", "below", "both", "none"]).optional(),
+    showShipping: import_zod41.z.boolean().optional().default(true),
+    showSubtotal: import_zod41.z.boolean().optional().default(true),
+    showTaxes: import_zod41.z.boolean().optional().default(true),
+    showTotal: import_zod41.z.boolean().optional().default(true),
+    showVariantSelectors: import_zod41.z.boolean().optional().default(true),
+    variantSelectorDisplayMode: import_zod41.z.enum(["separate", "single"]).optional().default("separate")
+  }),
+  productType: import_zod41.z.union([import_zod41.z.enum(["one-time", "subscription", "both"]), import_zod41.z.literal("").transform(() => "one-time")]).default("one-time"),
+  productTypeSelector: import_zod41.z.enum(["dropdown", "radio"]).optional().default("radio"),
+  quantityInputs: import_zod41.z.object({
+    defaultQuantity: import_zod41.z.union([import_zod41.z.number(), import_zod41.z.null().transform(() => 1)]).default(1),
+    enabled: import_zod41.z.boolean().default(true),
+    maxValue: import_zod41.z.union([import_zod41.z.number(), import_zod41.z.null().transform(() => 15)]).default(15),
+    minValue: import_zod41.z.union([import_zod41.z.number().min(0), import_zod41.z.unknown().transform(() => 0)]).default(1)
+  }),
+  shipping: import_zod41.z.object({
+    amount: strictNumber.default(10),
+    /** This isn't configurable in the admin-nextjs editor */
+    enabled: import_zod41.z.boolean().default(true),
+    title: import_zod41.z.string().optional().default("Shipping Fees"),
+    type: import_zod41.z.enum(["free", "fixed_amount"]).default("free")
+  }),
+  styles: import_zod41.z.object({
+    starColor: import_zod41.z.string().optional().default("#fadb14"),
+    starSize: import_zod41.z.union([import_zod41.z.enum(["small", "medium", "large"]), import_zod41.z.unknown().transform(() => "large")]).optional().default("large"),
+    starStrokeColor: import_zod41.z.string().optional().default("#fadb14"),
+    strokeWidth: import_zod41.z.string().optional().default("1")
+  }).optional(),
+  subImages: import_zod41.z.number().nullish().default(8),
+  subscription: import_zod41.z.object({
+    discount: import_zod41.z.object({
+      amount: strictNumber.default(30),
+      shouldShowSavingText: import_zod41.z.boolean().optional().default(true),
+      type: import_zod41.z.enum(["none", "fixed_amount", "percentage"]).default("none")
+    }),
+    shipping: import_zod41.z.object({
+      amount: strictNumber.default(1),
+      /** This isn't configurable in the admin-nextjs editor */
+      enabled: import_zod41.z.boolean().default(true),
+      /** This isn't configurable in the admin-nextjs editor */
+      recurringAmount: strictNumber.default(2),
+      shippingTitle: import_zod41.z.string().default("Shipping Fees"),
+      type: import_zod41.z.enum(["free", "fixed_amount"]).default("free")
+    })
+  }).optional().default({
+    discount: {
+      amount: 30,
+      shouldShowSavingText: true,
+      type: "none"
+    },
+    shipping: {
+      amount: 1,
+      /** This isn't configurable in the admin-nextjs editor */
+      enabled: true,
+      /** This isn't configurable in the admin-nextjs editor */
+      recurringAmount: 2,
+      shippingTitle: "Shipping Fees",
+      type: "free"
+    }
+  }),
+  subscriptionIsDefault: import_zod41.z.boolean().optional(),
+  /** This isn't configurable in the admin-nextjs editor */
+  template: import_zod41.z.string().optional().default(""),
+  type: import_zod41.z.literal("shopify_post_purchase_extension").default("shopify_post_purchase_extension"),
+  upgradeToSubscription: import_zod41.z.object({
+    acceptButtonText: import_zod41.z.string().optional().default("Upgrade"),
+    allow: import_zod41.z.boolean().optional().default(false),
+    emailRefundNotice: import_zod41.z.boolean().optional().default(false),
+    errorBannerText: import_zod41.z.string().optional().default("This subscription cannot be added - limit one per order")
+  }).optional().default(() => ({
+    acceptButtonText: "Upgrade",
+    allow: false,
+    emailRefundNotice: false,
+    errorBannerText: "This subscription cannot be added - limit one per order"
+  }))
+});
+
+// src/schema/postPurchaseProductSettings.ts
+var amount = import_zod42.z.union([import_zod42.z.number().nonnegative(), PostPurchaseAmount.transform(Number)]);
+var PostPurchaseProductSettings = PostPurchaseSettings.pick({
+  discountedFrom: true,
+  language: true,
+  productLimit: true,
+  productOptions: true,
+  productType: true,
+  productTypeSelector: true,
+  quantityInputs: true,
+  subscriptionIsDefault: true,
+  upgradeToSubscription: true
+}).extend({
+  advance: import_zod42.z.unknown().default({}),
+  blocks: import_zod42.z.array(import_zod42.z.unknown()).optional(),
+  discount: PostPurchaseSettings.shape.discount.extend({ amount: amount.default(30) }),
+  integrations: import_zod42.z.unknown().default({}),
+  shipping: PostPurchaseSettings.shape.shipping.extend({ amount: amount.default(10) }),
+  styles: import_zod42.z.unknown().default({}),
+  subImages: PostPurchaseSettings.shape.subImages.catch(null),
+  subscription: import_zod42.z.unknown().default(PostPurchaseSettings.shape.subscription.parse(void 0))
+});
+
+// src/server/normalizePostPurchaseProduct.ts
+var normalizePostPurchaseProduct = (settings, response) => {
+  const original = PostPurchaseProductSettings.parse(deepCamelCase(settings));
+  const { data, metadata } = PostPurchaseProductSource.parse(deepCamelCase(response));
+  const overrides = Object.fromEntries(Object.entries(metadata.widget).filter(([key]) => key in original));
+  const discount = import_zod43.z.object({ type: import_zod43.z.string() }).safeParse(overrides.discount);
+  if (discount.success && discount.data.type === "fixed") {
+    overrides.discount = { ...import_zod43.z.record(import_zod43.z.string(), import_zod43.z.unknown()).parse(overrides.discount), type: "fixed_amount" };
+  }
+  const effective = PostPurchaseProductSettings.parse((0, import_compat6.merge)({}, original, overrides));
+  return { data, effective, metadata, original };
+};
+
+// src/schema/postPurchasePlanCatalog.ts
+var import_zod46 = require("zod");
+
+// src/schema/postPurchasePlanAdjustment.ts
+var import_zod45 = require("zod");
+
+// src/schema/postPurchaseDiscount.ts
+var import_zod44 = require("zod");
+var Discount = import_zod44.z.object({
+  amount: import_zod44.z.number().nonnegative(),
+  title: import_zod44.z.string(),
+  type: import_zod44.z.enum(["none", "fixed_amount", "percentage"])
+});
+var validPostPurchaseDiscount = (discount) => discount.type !== "percentage" || discount.amount <= 100;
+var PostPurchaseDiscount = Discount.refine(validPostPurchaseDiscount);
+
+// src/schema/postPurchasePlanAdjustment.ts
+var PostPurchasePlanAdjustment = import_zod45.z.object({
+  amount: PostPurchaseDiscount.shape.amount,
+  type: import_zod45.z.enum(["percentage", "fixed_amount", "price"])
+}).refine(({ amount: amount2, type }) => type === "price" || validPostPurchaseDiscount({ amount: amount2, type }));
+
+// src/schema/postPurchasePlanCatalog.ts
+var PostPurchasePlanOption = import_zod46.z.object({
+  adjustment: PostPurchasePlanAdjustment.optional(),
+  id: import_zod46.z.number().int().positive(),
+  intervalFrequency: import_zod46.z.string().regex(/^[1-9]\d*$/).optional(),
+  intervalLabel: import_zod46.z.string().min(1),
+  name: import_zod46.z.string().min(1)
+});
+var PostPurchasePlanCatalog = import_zod46.z.object({
+  plans: import_zod46.z.array(PostPurchasePlanOption),
+  productId: import_zod46.z.number().int().positive(),
+  requiresSellingPlan: import_zod46.z.boolean(),
+  variantId: import_zod46.z.number().int().positive()
+});
+
+// src/server/postPurchaseLegacyPlans.ts
+var import_zod48 = require("zod");
+
+// src/server/postPurchasePlanAdjustment.ts
+var import_zod47 = require("zod");
+var SourceAdjustment = import_zod47.z.object({
+  amount: PostPurchaseProductSettings.shape.discount.shape.amount.unwrap(),
+  type: import_zod47.z.enum(["percentage", "fixed_amount", "amount", "price", "none", "fixed"])
+});
+var readPostPurchasePlanAdjustment = (raw) => {
+  const source = SourceAdjustment.parse(raw);
+  if (source.type === "none" || source.type === "fixed") {
+    if (source.amount !== 0) throw new Error("Unsupported plan adjustment");
+    return void 0;
+  }
+  const adjustment = PostPurchasePlanAdjustment.parse({
+    amount: source.amount,
+    type: source.type === "amount" ? "fixed_amount" : source.type
+  });
+  return adjustment.amount === 0 && adjustment.type !== "price" ? void 0 : adjustment;
+};
+
+// src/server/postPurchaseLegacyPlans.ts
+var Plan = PostPurchasePlanOption.pick({ id: true, name: true }).extend({
+  orderIntervalFrequency: PostPurchasePlanOption.shape.intervalFrequency.unwrap(),
+  orderIntervalUnitType: PostPurchasePlanOption.shape.intervalLabel,
+  shopifyVariantId: import_zod48.z.string().regex(/^[1-9]\d*$/).nullish()
+});
+var Group = import_zod48.z.object({
+  discountAmount: import_zod48.z.unknown(),
+  discountType: import_zod48.z.unknown(),
+  id: import_zod48.z.number().int().positive(),
+  sellingPlans: import_zod48.z.array(import_zod48.z.object({ shopifyVariantId: Plan.shape.shopifyVariantId }).passthrough())
+});
+var readPostPurchaseLegacyPlans = (raw, variantId) => {
+  const group = Group.pick({ id: true, sellingPlans: true }).parse(raw);
+  const rows = group.sellingPlans.filter((row) => row.shopifyVariantId === String(variantId));
+  if (!rows.length) return [];
+  const terms = Group.parse(raw);
+  const adjustment = readPostPurchasePlanAdjustment({ amount: terms.discountAmount, type: terms.discountType });
+  return rows.map((row) => {
+    const plan = Plan.parse(row);
+    return {
+      ...adjustment ? { adjustment } : {},
+      id: plan.id,
+      intervalFrequency: plan.orderIntervalFrequency,
+      intervalLabel: plan.orderIntervalUnitType,
+      name: plan.name
+    };
+  });
+};
+
+// src/server/postPurchaseModernPlans.ts
+var import_zod49 = require("zod");
+var Groups = import_zod49.z.array(
+  import_zod49.z.object({
+    id: import_zod49.z.string().min(1),
+    sellingPlans: import_zod49.z.unknown()
+  })
+);
+var Allocations = import_zod49.z.array(import_zod49.z.object({ sellingPlanGroupId: import_zod49.z.string().min(1) })).default([]);
+var Plans = import_zod49.z.array(
+  PostPurchasePlanOption.pick({ id: true, name: true }).extend({
+    options: import_zod49.z.array(import_zod49.z.object({ value: import_zod49.z.string().min(1) })).min(1),
+    priceAdjustments: import_zod49.z.array(import_zod49.z.unknown())
+  })
+);
+var FirstAdjustment = import_zod49.z.object({
+  value: PostPurchaseProductSettings.shape.discount.shape.amount.unwrap(),
+  valueType: PostPurchasePlanAdjustment.shape.type
+});
+var readPostPurchaseModernPlans = (raw, allocations) => {
+  const groups = Groups.parse(raw);
+  const memberships = Allocations.parse(allocations);
+  return groups.filter((group) => memberships.some((entry) => entry.sellingPlanGroupId === group.id)).flatMap(
+    (group) => Plans.parse(group.sellingPlans).map((plan) => {
+      const first = plan.priceAdjustments.length ? FirstAdjustment.parse(plan.priceAdjustments[0]) : void 0;
+      const adjustment = first && readPostPurchasePlanAdjustment({ amount: first.value, type: first.valueType });
+      return {
+        ...adjustment ? { adjustment } : {},
+        id: plan.id,
+        intervalLabel: plan.options[0].value,
+        name: plan.name
+      };
+    })
+  );
+};
+
+// src/server/postPurchasePlanCatalog.ts
+var projectPostPurchasePlanCatalog = (normalized, report) => {
+  try {
+    const { data } = normalized;
+    if (data.length !== 1 || data[0].variants.length !== 1) throw new Error("Ambiguous product");
+    const product = data[0];
+    const variant = product.variants[0];
+    if (variant.productId !== product.id) throw new Error("Foreign variant");
+    const groups = product.sellingPlanGroups;
+    const required = groups.map((group) => group.requiresSellingPlan);
+    if (required.some((flag) => flag !== required[0])) throw new Error("Conflicting requirement");
+    const plans = typeof groups[0]?.id === "number" ? readPostPurchaseLegacyPlans(groups[0], variant.id) : readPostPurchaseModernPlans(groups, variant.sellingPlanAllocations);
+    const unique = /* @__PURE__ */ new Map();
+    for (const plan of plans) {
+      const previous = unique.get(plan.id);
+      if (previous && JSON.stringify(previous) !== JSON.stringify(plan)) throw new Error("Conflicting plan");
+      unique.set(plan.id, plan);
+    }
+    return PostPurchasePlanCatalog.parse({
+      plans: [...unique.values()],
+      productId: product.id,
+      requiresSellingPlan: required[0] ?? false,
+      variantId: variant.id
+    });
+  } catch {
+    report?.({ detail: "Unreadable post-purchase plan catalog", kind: "product" });
+    return null;
+  }
+};
+
+// src/schema/postPurchaseSubscriptionProduct.ts
+var import_zod54 = require("zod");
+
+// src/schema/postPurchaseProduct.ts
+var import_zod53 = require("zod");
+
+// src/schema/postPurchaseProductDisplay.ts
+var import_zod51 = require("zod");
+
+// src/schema/postPurchaseProductGallery.ts
+var import_zod50 = require("zod");
+var PostPurchaseProductGallery = import_zod50.z.object({
+  images: import_zod50.z.array(
+    import_zod50.z.object({
+      description: import_zod50.z.string(),
+      id: import_zod50.z.number().int().positive(),
+      source: import_zod50.z.string(),
+      thumbnail: import_zod50.z.string()
+    })
+  ),
+  selectedImageId: import_zod50.z.number().int().positive().optional()
+});
+
+// src/schema/postPurchaseProductDisplay.ts
+var language = PostPurchaseSettings.shape.language;
+var PostPurchasePrimaryImageSource = import_zod51.z.string().default(
+  "https://cdn.shopify.com/shopifycloud/shopify/assets/no-image-2048-5e88c1b20e087fb7bbe9a3771824e743c244f437e4f8ba93bbf7b11b53f7824c.gif"
+);
+var PostPurchaseProductDisplay = import_zod51.z.object({
+  discountedFrom: PostPurchaseSettings.shape.discountedFrom,
+  gallery: PostPurchaseProductGallery.optional(),
+  language: language.pick({
+    description: true,
+    descriptionEnabled: true,
+    descriptionRte: true,
+    descriptionSpacing: true
+  }),
+  primaryImage: import_zod51.z.object({ description: import_zod51.z.string(), source: import_zod51.z.string() }),
+  productOptions: PostPurchaseSettings.shape.productOptions.pick({
+    showDeclineAll: true,
+    showShipping: true,
+    showSubtotal: true,
+    showTaxes: true,
+    showTotal: true,
+    showVariantSelectors: true
+  }),
+  responseDescription: language.shape.description,
+  shouldShowSavingText: PostPurchaseSettings.shape.discount.shape.shouldShowSavingText
+});
+
+// src/schema/postPurchaseSubscription.ts
+var import_zod52 = require("zod");
+var PostPurchaseSubscriptionTerms = import_zod52.z.object({
+  adjustment: PostPurchasePlanAdjustment.optional(),
+  initialShippingPrice: import_zod52.z.number().nonnegative(),
+  intervalLabel: import_zod52.z.string().min(1),
+  name: import_zod52.z.string().min(1),
+  recurringShippingPrice: import_zod52.z.number().nonnegative(),
+  shippingOption: import_zod52.z.object({ presentmentTitle: import_zod52.z.string(), title: import_zod52.z.string() })
+});
+
+// src/schema/postPurchaseProduct.ts
+var global = PostPurchaseSettings.shape.language.shape.global.unwrap().unwrap().shape;
+var PostPurchaseVariant = OfferProduct.shape.variants.element.pick({ id: true, title: true }).extend({
+  compareAtPrice: PostPurchaseAmount.nullable(),
+  id: PostPurchaseVariantId,
+  price: PostPurchaseAmount
+});
+var PreparedPostPurchaseProduct = import_zod53.z.object({
+  display: PostPurchaseProductDisplay,
+  labels: import_zod53.z.object({
+    declineAll: global.declineAll,
+    free: import_zod53.z.string(),
+    payNow: import_zod53.z.string(),
+    quantity: import_zod53.z.string(),
+    recurringShipping: global.recurringShipping,
+    recurringSubtotal: global.recurringSubtotal,
+    save: import_zod53.z.string(),
+    shipping: import_zod53.z.string(),
+    subtotal: import_zod53.z.string(),
+    taxes: import_zod53.z.string(),
+    total: import_zod53.z.string()
+  }),
+  product: OfferProduct.pick({ description: true, id: true, image: true, title: true }).extend({
+    description: OfferProduct.shape.description.nullable(),
+    id: PostPurchaseProductId,
+    variant: PostPurchaseVariant
+  }),
+  selection: import_zod53.z.object({
+    productId: PostPurchaseProductId,
+    quantity: import_zod53.z.number().int().positive(),
+    sellingPlanId: import_zod53.z.number().int().positive().optional(),
+    variantId: PostPurchaseVariantId
+  }),
+  status: import_zod53.z.literal("prepared"),
+  terms: import_zod53.z.object({
+    discount: PostPurchaseDiscount,
+    shipping: import_zod53.z.object({
+      amount: import_zod53.z.number().nonnegative(),
+      title: import_zod53.z.string(),
+      type: import_zod53.z.enum(["free", "fixed_amount"])
+    }),
+    subscription: PostPurchaseSubscriptionTerms.optional()
+  })
+});
+var PostPurchasePreparation = import_zod53.z.discriminatedUnion("status", [
+  PreparedPostPurchaseProduct,
+  import_zod53.z.object({ reason: import_zod53.z.string(), status: import_zod53.z.literal("unsupported") })
+]);
+
+// src/schema/postPurchaseSubscriptionProduct.ts
+var PreparedPostPurchaseSubscription = PreparedPostPurchaseProduct.extend({
+  selection: PreparedPostPurchaseProduct.shape.selection.extend({ sellingPlanId: import_zod54.z.number().int().positive() }),
+  terms: PreparedPostPurchaseProduct.shape.terms.extend({
+    subscription: PostPurchaseSubscriptionTerms
+  }).refine(
+    ({ discount, shipping, subscription: subscription2 }) => (discount.type !== "none" || discount.amount === 0) && shipping.amount === subscription2.initialShippingPrice && shipping.amount === subscription2.recurringShippingPrice && (shipping.type !== "free" || shipping.amount === 0)
+  )
+});
+
+// src/schema/postPurchaseSubscriptionSettings.ts
+var subscription = PostPurchaseSettings.shape.subscription.unwrap().unwrap();
+var PostPurchaseSubscriptionSettings = subscription.extend({
+  discount: subscription.shape.discount.extend({
+    amount: PostPurchaseProductSettings.shape.discount.shape.amount.unwrap().default(subscription.shape.discount.shape.amount.parse(void 0))
+  }).refine(validPostPurchaseDiscount),
+  shipping: subscription.shape.shipping.extend({
+    amount: PostPurchaseProductSettings.shape.shipping.shape.amount.unwrap().default(subscription.shape.shipping.shape.amount.parse(void 0))
+  })
+});
+
+// src/server/postPurchaseVariantAvailable.ts
+var postPurchaseVariantAvailable = (variant) => !(variant.inventoryManagement && variant.inventoryPolicy === "deny" && variant.inventoryQuantity <= 0);
+
+// src/server/postPurchaseSubscriptionEligibility.ts
+var subscriptionUnavailable = (normalized, plan, allowCollection, quantity) => {
+  const { data, effective, original } = normalized;
+  const unavailable = "An eligible subscription plan with supported shipping and discount is required";
+  if (data.length !== 1 || data[0].variants.length !== 1) return unavailable;
+  if (effective.productType === "one-time" || [original, effective].some(
+    (config) => !allowCollection && config.productLimit !== 1 || config.upgradeToSubscription.allow || !quantity && config.quantityInputs.enabled && (config.quantityInputs.minValue !== config.quantityInputs.maxValue || config.quantityInputs.defaultQuantity !== config.quantityInputs.minValue)
+  ))
+    return unavailable;
+  const product = data[0];
+  const variant = product.variants[0];
+  if (product.productGroupVariants.length || !postPurchaseVariantAvailable(variant) || variant.productId !== product.id)
+    return unavailable;
+  const terms = [original, effective].map(
+    (config) => PostPurchaseSubscriptionSettings.safeParse(config.subscription)
+  );
+  if (!plan || terms.some((term) => !term.success)) return unavailable;
+};
+
+// src/server/postPurchaseProductDisplay.ts
+var import_zod55 = require("zod");
+
+// src/server/postPurchasePrimaryImage.ts
+var postPurchasePrimaryImage = (product) => {
+  const variantImageId = product.variants[0].imageId;
+  const selectedImage = variantImageId ? product.images?.find((image) => image.id === variantImageId) : void 0;
+  const source = PostPurchasePrimaryImageSource.parse((selectedImage ?? product.image)?.src || void 0);
+  return { description: product.title, source: sizeImageSource(source, "800x800") };
+};
+
+// src/server/postPurchaseProductGallery.ts
+var postPurchaseProductGallery = (product, limit) => ({
+  images: (product.images ?? []).slice(0, limit ?? 0).map((image) => ({
+    description: image.alt ?? product.title,
+    id: image.id,
+    source: sizeImageSource(image.src, "800x800"),
+    thumbnail: sizeImageSource(image.src, "200x200")
+  })),
+  selectedImageId: product.images?.find((image) => image.id === product.variants[0].imageId)?.id
+});
+
+// src/server/postPurchaseProductDisplay.ts
+var ResponseLanguage = import_zod55.z.object({ description: PostPurchaseProductDisplay.shape.responseDescription }).default({ description: "" });
+var projectPostPurchaseProductDisplay = (effective, metadata, product) => PostPurchaseProductDisplay.parse({
+  discountedFrom: effective.discountedFrom,
+  gallery: postPurchaseProductGallery(product, effective.subImages),
+  language: effective.language,
+  primaryImage: postPurchasePrimaryImage(product),
+  productOptions: effective.productOptions,
+  responseDescription: ResponseLanguage.parse(metadata.widget.language).description,
+  shouldShowSavingText: effective.discount.shouldShowSavingText
+});
+
+// src/server/projectPostPurchaseProduct.ts
+var projectPostPurchaseProduct = ({ data, effective, metadata, original }, selectedQuantity) => {
+  const product = data[0];
+  const variant = product.variants[0];
+  return {
+    display: projectPostPurchaseProductDisplay(effective, metadata, product),
+    labels: effective.language.global,
+    product: { ...product, variant },
+    selection: {
+      productId: product.id,
+      quantity: selectedQuantity?.quantity ?? product.metadata?.productQuantity ?? (original.quantityInputs.enabled ? original.quantityInputs.defaultQuantity : 1),
+      variantId: variant.id
+    }
+  };
+};
+
+// src/server/prepareNormalizedSubscription.ts
+var prepareNormalizedSubscription = (normalized, report, plan, quantity, allowCollection = false) => {
+  if (!plan) return { reason: "Subscription plan is unavailable", status: "unsupported" };
+  const reason = subscriptionUnavailable(normalized, plan, allowCollection, quantity);
+  if (reason) return { reason, status: "unsupported" };
+  const { effective } = normalized;
+  const projected = projectPostPurchaseProduct(normalized, quantity);
+  const { discount, shipping } = PostPurchaseSubscriptionSettings.parse(effective.subscription);
+  const shippingPrice = shipping.type === "free" ? 0 : shipping.amount;
+  return PreparedPostPurchaseSubscription.parse({
+    ...projected,
+    display: { ...projected.display, shouldShowSavingText: discount.shouldShowSavingText },
+    selection: { ...projected.selection, sellingPlanId: plan.id },
+    status: "prepared",
+    terms: {
+      discount: {
+        amount: discount.type === "none" ? 0 : discount.amount,
+        title: effective.language.global.save,
+        type: discount.type
+      },
+      shipping: { amount: shippingPrice, title: "Subscription shipping line", type: shipping.type },
+      subscription: {
+        ...plan.adjustment ? { adjustment: plan.adjustment } : {},
+        initialShippingPrice: shippingPrice,
+        intervalLabel: plan.intervalLabel,
+        name: plan.name,
+        recurringShippingPrice: shippingPrice,
+        shippingOption: { presentmentTitle: "Subscription shipping line", title: "Subscription shipping line" }
+      }
+    }
+  });
+};
+
+// src/server/preparePostPurchaseSubscription.ts
+var preparePostPurchaseSubscription = (settings, response, report) => {
+  const normalized = normalizePostPurchaseProduct(settings, response);
+  return prepareNormalizedSubscription(
+    normalized,
+    report,
+    projectPostPurchasePlanCatalog(normalized, report)?.plans[0]
+  );
+};
+
 // src/server/analytics.ts
 var import_es_toolkit7 = require("es-toolkit");
 
@@ -5638,7 +6322,7 @@ var postAnalyticsEvents = async (input, ctx) => {
 };
 
 // src/server/requestSchemas.ts
-var import_zod39 = require("zod");
+var import_zod56 = require("zod");
 var REQUEST_BOUNDS = {
   /** Cart-level attributes per cart. */
   CART_ATTRIBUTES_MAX: 100,
@@ -5669,42 +6353,42 @@ var REQUEST_BOUNDS = {
   /** Rich ads transaction lines — the engine's ads contract. */
   TRANSACTION_ITEMS_MAX: 50
 };
-var KeyValue = import_zod39.z.object({
-  key: import_zod39.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX),
-  value: import_zod39.z.string().max(REQUEST_BOUNDS.STRING_VALUE_MAX).optional()
+var KeyValue = import_zod56.z.object({
+  key: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX),
+  value: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_VALUE_MAX).optional()
 });
-var CartLineInputSchema = import_zod39.z.object({
-  productId: import_zod39.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
-  properties: import_zod39.z.array(KeyValue).max(REQUEST_BOUNDS.LINE_PROPERTIES_MAX).optional(),
-  quantity: import_zod39.z.number(),
-  subscriptionId: import_zod39.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  variantId: import_zod39.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX)
+var CartLineInputSchema = import_zod56.z.object({
+  productId: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  properties: import_zod56.z.array(KeyValue).max(REQUEST_BOUNDS.LINE_PROPERTIES_MAX).optional(),
+  quantity: import_zod56.z.number(),
+  subscriptionId: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  variantId: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX)
 });
-var CartInputSchema = import_zod39.z.object({
-  attributes: import_zod39.z.array(KeyValue).max(REQUEST_BOUNDS.CART_ATTRIBUTES_MAX).optional(),
+var CartInputSchema = import_zod56.z.object({
+  attributes: import_zod56.z.array(KeyValue).max(REQUEST_BOUNDS.CART_ATTRIBUTES_MAX).optional(),
   /**
    * Presentment-per-shop-currency FX rate (buyer price ÷ shop price, e.g. `1.35` for a USD shop
    * selling in CAD). Money rule thresholds are authored in SHOP currency, so the engine subtotal is
    * divided by this before evaluation. Omit (or send 1) when the cart is already in the shop's currency.
    */
-  currencyRate: import_zod39.z.number().optional(),
+  currencyRate: import_zod56.z.number().optional(),
   /** Applied discount codes; the engine evaluates `discount_code` rules against them (sent as `[{code}]`). */
-  discountCodes: import_zod39.z.array(import_zod39.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX)).max(REQUEST_BOUNDS.DISCOUNT_CODES_MAX).optional(),
+  discountCodes: import_zod56.z.array(import_zod56.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX)).max(REQUEST_BOUNDS.DISCOUNT_CODES_MAX).optional(),
   /** Presentment cents of cart-level discount allocations, subtracted from `subtotal` for the engine. */
-  discountTotal: import_zod39.z.number().optional(),
-  items: import_zod39.z.array(CartLineInputSchema).max(REQUEST_BOUNDS.CART_ITEMS_MAX),
+  discountTotal: import_zod56.z.number().optional(),
+  items: import_zod56.z.array(CartLineInputSchema).max(REQUEST_BOUNDS.CART_ITEMS_MAX),
   /** Presentment subtotal in cents. */
-  subtotal: import_zod39.z.number()
+  subtotal: import_zod56.z.number()
 });
-var UserConfigInputSchema = import_zod39.z.object({ shop: import_zod39.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX) });
-var DataSourceInputSchema = import_zod39.z.object({
+var UserConfigInputSchema = import_zod56.z.object({ shop: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX) });
+var DataSourceInputSchema = import_zod56.z.object({
   cart: CartInputSchema,
   /**
    * Numeric Shopify company-location id when the buyer is a B2B session (`buyerIdentity.purchasingCompany`).
    * Present ⇒ the orchestrator filters results by the location's catalog via admin-api (REB-23713); the
    * client's country-context market check is bypassed for B2B (it false-negatives B2B-catalog products).
    */
-  companyLocationId: import_zod39.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  companyLocationId: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
   /**
    * Buyer's market country (ISO 3166-1 alpha-2) — forwarded to the engine as the `country_code` PARAM
    * when the shop's markets toggle is on (REB-21688; the sink was the `X-Country-Code` header under
@@ -5713,16 +6397,16 @@ var DataSourceInputSchema = import_zod39.z.object({
    * uppercase (the wire value is forwarded verbatim as the param) so a case-sensitive engine lookup
    * can't silently miss a lowercase code — `adsEngine.ts` uppercases for the same reason.
    */
-  country: import_zod39.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).regex(/^[A-Za-z]{2}$/, "must be an ISO 3166-1 alpha-2 country code (e.g. CA)").transform((value) => value.toUpperCase()).optional(),
-  customerId: import_zod39.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  dataSourcePath: import_zod39.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX),
+  country: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).regex(/^[A-Za-z]{2}$/, "must be an ISO 3166-1 alpha-2 country code (e.g. CA)").transform((value) => value.toUpperCase()).optional(),
+  customerId: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  dataSourcePath: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX),
   /**
    * Engine `filter_inputs` override: `'no'` keeps in-cart (input) products in the results/rule
    * outputs — gift validation sends it so a gift's own product can appear in its answer. Omitted = the
    * engine's default filtering.
    */
-  filterInputs: import_zod39.z.enum(["no", "yes"]).optional(),
-  integrations: import_zod39.z.record(import_zod39.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX), import_zod39.z.boolean()).refine((record) => Object.keys(record).length <= REQUEST_BOUNDS.INTEGRATION_KEYS_MAX, {
+  filterInputs: import_zod56.z.enum(["no", "yes"]).optional(),
+  integrations: import_zod56.z.record(import_zod56.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX), import_zod56.z.boolean()).refine((record) => Object.keys(record).length <= REQUEST_BOUNDS.INTEGRATION_KEYS_MAX, {
     message: `Too many integration keys (max ${REQUEST_BOUNDS.INTEGRATION_KEYS_MAX})`
   }).optional(),
   /**
@@ -5735,31 +6419,31 @@ var DataSourceInputSchema = import_zod39.z.object({
    * request header) fails the regex. Callers should send the buyer's resolved locale (e.g. Shopify
    * checkout's `localization.language.isoCode`), not the request header verbatim.
    */
-  language: import_zod39.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).regex(/^[A-Za-z0-9-]+$/, "must be a single BCP-47 tag (e.g. fr-CA), not a q-value list").optional(),
-  limit: import_zod39.z.number().max(REQUEST_BOUNDS.LIMIT_MAX),
-  productType: import_zod39.z.enum(["both", "one-time", "subscription"]).optional(),
-  shop: import_zod39.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
-  visitorId: import_zod39.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
-});
-var GiftInputSchema = import_zod39.z.object({
-  cost: import_zod39.z.number(),
-  discounted: import_zod39.z.boolean(),
+  language: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).regex(/^[A-Za-z0-9-]+$/, "must be a single BCP-47 tag (e.g. fr-CA), not a q-value list").optional(),
+  limit: import_zod56.z.number().max(REQUEST_BOUNDS.LIMIT_MAX),
+  productType: import_zod56.z.enum(["both", "one-time", "subscription"]).optional(),
+  shop: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  visitorId: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
+});
+var GiftInputSchema = import_zod56.z.object({
+  cost: import_zod56.z.number(),
+  discounted: import_zod56.z.boolean(),
   /**
    * Which gift attribution the line carries (REB-24363). Defaults to `gwp` because a client that predates
    * the field only ever sent GWP lines — without the default an older extension's request would 422.
    */
-  kind: import_zod39.z.enum(GIFT_KINDS).default("gwp"),
-  lineId: import_zod39.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
-  productId: import_zod39.z.number(),
+  kind: import_zod56.z.enum(GIFT_KINDS).default("gwp"),
+  lineId: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  productId: import_zod56.z.number(),
   /**
    * The line's unit count (REB-24363) — the selectable-GWP verdict trims surplus units against milestone
    * capacity. The second deliberate default: a client predating the field sent only GWP lines, whose
    * verdict is whole-line, so a missing quantity reads as one unit rather than 422ing the older request.
    */
-  quantity: import_zod39.z.number().int().min(1).default(1),
-  widgetId: import_zod39.z.number()
+  quantity: import_zod56.z.number().int().min(1).default(1),
+  widgetId: import_zod56.z.number()
 });
-var GiftValidationInputSchema = import_zod39.z.object({
+var GiftValidationInputSchema = import_zod56.z.object({
   cart: CartInputSchema,
   /**
    * Buyer's market country — threaded into the per-widget data-source evaluations, which forward it to
@@ -5768,25 +6452,25 @@ var GiftValidationInputSchema = import_zod39.z.object({
    * turns markets off); regex-bound and uppercase-normalized for the same reasons as
    * `DataSourceInputSchema`'s `country`.
    */
-  country: import_zod39.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).regex(/^[A-Za-z]{2}$/, "must be an ISO 3166-1 alpha-2 country code (e.g. CA)").transform((value) => value.toUpperCase()).optional(),
-  customerId: import_zod39.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  gifts: import_zod39.z.array(GiftInputSchema).max(REQUEST_BOUNDS.GIFTS_MAX),
+  country: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).regex(/^[A-Za-z]{2}$/, "must be an ISO 3166-1 alpha-2 country code (e.g. CA)").transform((value) => value.toUpperCase()).optional(),
+  customerId: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  gifts: import_zod56.z.array(GiftInputSchema).max(REQUEST_BOUNDS.GIFTS_MAX),
   /**
    * Buyer's checkout language — threaded into the per-widget data-source evaluations, which normalize
    * and forward it as the engine `locale` param under the same markets-toggle gate (REB-21688). MUST be
    * a single BCP-47 tag, for the same reason as `DataSourceInputSchema`'s `language` above.
    */
-  language: import_zod39.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).regex(/^[A-Za-z0-9-]+$/, "must be a single BCP-47 tag (e.g. fr-CA), not a q-value list").optional(),
-  shop: import_zod39.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
-  visitorId: import_zod39.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
+  language: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).regex(/^[A-Za-z0-9-]+$/, "must be a single BCP-47 tag (e.g. fr-CA), not a q-value list").optional(),
+  shop: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  visitorId: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
 });
-var GiftAdjustmentSchema = import_zod39.z.object({
-  lineId: import_zod39.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
-  quantity: import_zod39.z.number().int().nonnegative()
+var GiftAdjustmentSchema = import_zod56.z.object({
+  lineId: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  quantity: import_zod56.z.number().int().nonnegative()
 });
-var GiftValidationResponseSchema = import_zod39.z.object({
-  adjust: import_zod39.z.array(GiftAdjustmentSchema).max(REQUEST_BOUNDS.GIFTS_MAX).default([]),
-  remove: import_zod39.z.array(import_zod39.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX)).max(REQUEST_BOUNDS.GIFTS_MAX).refine(
+var GiftValidationResponseSchema = import_zod56.z.object({
+  adjust: import_zod56.z.array(GiftAdjustmentSchema).max(REQUEST_BOUNDS.GIFTS_MAX).default([]),
+  remove: import_zod56.z.array(import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX)).max(REQUEST_BOUNDS.GIFTS_MAX).refine(
     (remove) => new Set(remove).size === remove.length,
     "a line id may appear at most once in `remove`"
   )
@@ -5797,47 +6481,47 @@ var GiftValidationResponseSchema = import_zod39.z.object({
   ({ adjust }) => new Set(adjust.map(({ lineId }) => lineId)).size === adjust.length,
   "a line id may appear at most once in `adjust`"
 );
-var MonetizeTransactionItemSchema = import_zod39.z.object({
-  id: import_zod39.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
-  priceCents: import_zod39.z.number(),
-  quantity: import_zod39.z.number(),
-  title: import_zod39.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX),
-  type: import_zod39.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX)
-});
-var MonetizeInputSchema = import_zod39.z.object({
+var MonetizeTransactionItemSchema = import_zod56.z.object({
+  id: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  priceCents: import_zod56.z.number(),
+  quantity: import_zod56.z.number(),
+  title: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX),
+  type: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX)
+});
+var MonetizeInputSchema = import_zod56.z.object({
   cart: CartInputSchema,
   /** Client-minted render-beacon correlation id; forwarded to the ads engine as `client_request_id`. */
-  clientRequestId: import_zod39.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  country: import_zod39.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  currency: import_zod39.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  clientRequestId: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  country: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  currency: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
   /** Ads-targeting identity/geo/locale fields (React parity); folded into the engine query verbatim. */
-  customerEmail: import_zod39.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
-  customerFirstName: import_zod39.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
-  customerId: import_zod39.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  customerLastName: import_zod39.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
-  language: import_zod39.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  customerEmail: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
+  customerFirstName: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
+  customerId: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  customerLastName: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
+  language: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
   /** Buyer-facing order name (e.g. `#1001`) for the server-composed "Order … Confirmed" chrome line. */
-  orderName: import_zod39.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
+  orderName: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
   /** Ads surface label, forwarded verbatim; `customer_account` is measured/floored as its own surface (the account-area order list). */
-  placement: import_zod39.z.enum(["customer_account", "order_status", "thank_you_page"]),
+  placement: import_zod56.z.enum(["customer_account", "order_status", "thank_you_page"]),
   /** Privacy Policy footer href — the Monetize widget's `privacy_policy_url` setting (React parity). */
-  privacyPolicyUrl: import_zod39.z.string().max(REQUEST_BOUNDS.STRING_URL_MAX).optional(),
+  privacyPolicyUrl: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_URL_MAX).optional(),
   /** 30-min rolling session id (React parity); used for the ads `session_id`, else the visitor id. */
-  sessionId: import_zod39.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  shop: import_zod39.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  sessionId: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  shop: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
   /** Editor/QA indicator; OR-ed into the ads-engine `testing` flag so it stays out of billing/reporting. */
-  testing: import_zod39.z.boolean().optional(),
-  timezone: import_zod39.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  testing: import_zod56.z.boolean().optional(),
+  timezone: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
   /** Decorated (numeric) order id → the ads `transaction_id`. */
-  transactionId: import_zod39.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  transactionId: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
   /** Rich per-line ads items; capped at the engine's ads contract. Preferred over `cart.items`. */
-  transactionItems: import_zod39.z.array(MonetizeTransactionItemSchema).max(REQUEST_BOUNDS.TRANSACTION_ITEMS_MAX).optional(),
+  transactionItems: import_zod56.z.array(MonetizeTransactionItemSchema).max(REQUEST_BOUNDS.TRANSACTION_ITEMS_MAX).optional(),
   /** Order total in presentment cents (React prefers total over subtotal); else `cart.subtotal`. */
-  transactionTotal: import_zod39.z.number().optional(),
-  visitorId: import_zod39.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  zipCode: import_zod39.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
+  transactionTotal: import_zod56.z.number().optional(),
+  visitorId: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  zipCode: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
 });
-var WidgetSettingsInputSchema = import_zod39.z.object({
+var WidgetSettingsInputSchema = import_zod56.z.object({
   /**
    * Same domain as `CabShopConfig.cacheKey`, for the same reason: this side WINS the orchestrator's
    * `input.cacheKey ?? config.shop.cacheKey` (and an explicit value skips the config read entirely), so
@@ -5845,9 +6529,9 @@ var WidgetSettingsInputSchema = import_zod39.z.object({
    * and pin the edge copy permanently stale. `.catch(undefined)` because a bogus buster should degrade
    * the read to un-busted, never 400 a widget render.
    */
-  cacheKey: import_zod39.z.number().int().positive().optional().catch(void 0),
-  id: import_zod39.z.number(),
-  key: import_zod39.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  cacheKey: import_zod56.z.number().int().positive().optional().catch(void 0),
+  id: import_zod56.z.number(),
+  key: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
   /**
    * Monetize context for inline hydration: when present AND the widget converts to a Monetize marker,
    * the server fetches/composes the offer cards inside this same request (no second `/cab/monetize`
@@ -5856,34 +6540,34 @@ var WidgetSettingsInputSchema = import_zod39.z.object({
    * `privacyPolicyUrl` comes from the widget settings server-side (more authoritative than a relay).
    */
   monetize: MonetizeInputSchema.omit({ privacyPolicyUrl: true, shop: true }).optional(),
-  shop: import_zod39.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  shop: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
   /** Stable per-buyer id; when present, enables sticky server-side A/B variant selection. */
-  visitorId: import_zod39.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
+  visitorId: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
 });
-var AnalyticsEventInputSchema = import_zod39.z.object({
-  name: import_zod39.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX),
-  properties: import_zod39.z.record(import_zod39.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX), import_zod39.z.unknown()).optional(),
-  sentAt: import_zod39.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
+var AnalyticsEventInputSchema = import_zod56.z.object({
+  name: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX),
+  properties: import_zod56.z.record(import_zod56.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX), import_zod56.z.unknown()).optional(),
+  sentAt: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
 });
-var AnalyticsSegmentsInputSchema = import_zod39.z.object({
-  device: import_zod39.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional().catch(void 0),
-  source: import_zod39.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional().catch(void 0),
-  visitor: import_zod39.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional().catch(void 0)
+var AnalyticsSegmentsInputSchema = import_zod56.z.object({
+  device: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional().catch(void 0),
+  source: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional().catch(void 0),
+  visitor: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional().catch(void 0)
 });
-var AnalyticsInputSchema = import_zod39.z.object({
+var AnalyticsInputSchema = import_zod56.z.object({
   /** Rebuy cart token (the `r_cart_token` cart attribute), when available — primary aggregation key. */
-  cartToken: import_zod39.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  cartToken: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
   /** Shopify checkout token, when available — drives cart/checkout aggregation downstream. */
-  checkoutToken: import_zod39.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  events: import_zod39.z.array(AnalyticsEventInputSchema).max(REQUEST_BOUNDS.EVENTS_MAX),
+  checkoutToken: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  events: import_zod56.z.array(AnalyticsEventInputSchema).max(REQUEST_BOUNDS.EVENTS_MAX),
   /**
    * Request-scoped like the tokens: one visitor's segments apply to every event in the batch. The container
    * degrades too (`null` is a realistic wire artifact of `attributes ? {…} : null`), so the degrade rule is
    * total: nothing about `segments` can cost the envelope.
    */
   segments: AnalyticsSegmentsInputSchema.optional().catch(void 0),
-  shop: import_zod39.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
-  visitorId: import_zod39.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  shop: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  visitorId: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
   /** The widget id (smartBlockId) the events belong to. */
-  widgetId: import_zod39.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
+  widgetId: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
 });