@rebuy/rebuy 3.32.0 → 3.33.0

package/dist/server/index.mjs

@@ -2213,10 +2213,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: [
@@ -2328,7 +2328,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({
@@ -3371,7 +3371,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),
@@ -3385,9 +3385,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"
     }
@@ -3443,10 +3443,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) => [
     {
@@ -3500,9 +3500,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]] : [];
   })
@@ -3599,7 +3599,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
@@ -3612,7 +3612,7 @@ var buildBanner = (language) => language?.successBannerEnabled ? [
     dismissible: true,
     sections: [
       {
-        content: bannerMessageContent(language.successBannerMessageRte),
+        content: bannerMessageContent(language2.successBannerMessageRte),
         sectionType: "text"
       },
       {
@@ -4446,8 +4446,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 ?? "")));
@@ -5451,6 +5451,689 @@ var validateGifts = async (input, ctx) => {
   return { adjust: [...targets].map(([lineId, quantity]) => ({ lineId, quantity })), remove: [...removed] };
 };
 
+// src/server/normalizePostPurchaseProduct.ts
+import { merge } from "es-toolkit/compat";
+import { z as z43 } from "zod";
+
+// src/schema/postPurchaseProductSettings.ts
+import { z as z42 } from "zod";
+
+// src/schema/postPurchaseProductSource.ts
+import { z as z39 } from "zod";
+var PostPurchaseAmount = z39.string().regex(/^\d+(?:\.\d+)?$/).refine((value) => Number.isFinite(Number(value)));
+var PostPurchaseProductId = z39.number().int().positive();
+var PostPurchaseVariantId = z39.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: z39.number().int().nonnegative().nullish(),
+  inventoryManagement: z39.string().nullable(),
+  inventoryPolicy: z39.string(),
+  inventoryQuantity: z39.number(),
+  option1: z39.unknown().optional(),
+  option2: z39.unknown().optional(),
+  option3: z39.unknown().optional(),
+  price: PostPurchaseAmount,
+  productId: PostPurchaseProductId,
+  sellingPlanAllocations: z39.unknown().optional()
+});
+var Product2 = ProductBase.extend({
+  images: z39.array(
+    z39.object({ alt: z39.string().optional().catch(void 0), id: z39.number().int().positive(), src: z39.string() })
+  ).nullish(),
+  metadata: z39.object({
+    productQuantity: z39.union([
+      z39.number().int().positive(),
+      z39.string().regex(/^[1-9]\d*$/).transform(Number)
+    ]).optional()
+  }).optional(),
+  metafields: z39.unknown().optional(),
+  options: z39.unknown().optional(),
+  productGroupVariants: z39.array(z39.unknown()).default([]),
+  selectedVariant: z39.unknown().optional(),
+  sellingPlanGroups: z39.array(
+    OfferProduct.shape.sellingPlanGroups.unwrap().element.extend({
+      discountAmount: z39.unknown().optional(),
+      discountType: z39.unknown().optional(),
+      id: z39.unknown().optional(),
+      requiresSellingPlan: z39.boolean().default(false),
+      sellingPlans: z39.unknown().optional()
+    })
+  ).default([]),
+  variants: z39.array(SourceVariant)
+});
+var PostPurchaseProductSource = z39.object({
+  data: z39.array(Product2),
+  metadata: z39.object({ widget: z39.record(z39.string(), z39.unknown()).default({}) }).default({ widget: {} })
+});
+
+// src/schema/widgets/post-purchase-offer/postPurchaseSettings.ts
+import { z as z41 } from "zod";
+
+// src/schema/widgets/post-purchase-offer/common.ts
+import { replace, toNumber, toString } from "es-toolkit/compat";
+import { z as z40 } from "zod";
+var strictNumber = z40.union([
+  z40.number(),
+  z40.string().transform((value) => toNumber(replace(toString(value), /[^0-9.]/g, "")) || 0),
+  z40.unknown().transform(() => 0)
+]);
+
+// src/schema/widgets/post-purchase-offer/postPurchaseSettings.ts
+var PostPurchaseSettings = z41.object({
+  advance: z41.object({ removePartialOrder: z41.boolean().default(true) }).optional().default(() => ({ removePartialOrder: true })),
+  blocks: z41.union([z41.array(PostPurchaseBlock), z41.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: z41.boolean().optional(),
+  discount: z41.object({
+    amount: strictNumber.default(30),
+    shouldShowSavingText: z41.boolean().optional().default(true),
+    type: z41.enum(["none", "fixed_amount", "percentage"]).default("none")
+  }),
+  discountedFrom: z41.enum(["price", "compare_at_price"]).optional().default("price"),
+  endpoint: z41.string().optional(),
+  integrations: z41.object({
+    judgeme: z41.boolean().default(false),
+    junip: z41.boolean().optional().default(false),
+    klaviyo: z41.boolean().default(false),
+    loox: z41.boolean().default(false),
+    okendo: z41.boolean().default(false),
+    opinew: z41.boolean().optional().default(false),
+    reviewsio: z41.boolean().optional().default(false),
+    stamped: z41.boolean().default(false),
+    yotpo: z41.boolean().default(false)
+  }),
+  key: z41.string().optional(),
+  language: z41.object({
+    description: z41.union([z41.string(), z41.unknown().transform(() => "")]).default(""),
+    descriptionEnabled: z41.boolean().optional().default(false),
+    descriptionRte: z41.object({
+      content: z41.array(z41.unknown()),
+      type: z41.string()
+    }).optional(),
+    descriptionSpacing: z41.enum(["none", "xtight", "tight", "default", "loose", "xloose"]).optional(),
+    displayCtaPrice: z41.boolean().default(true),
+    global: z41.object({
+      declineAll: z41.string().optional().default("Decline All"),
+      declineThisOffer: z41.string().default("Decline this offer"),
+      free: z41.string().optional().default("Free"),
+      notAvailable: z41.string().optional().default("Not available"),
+      payNow: z41.string().default("Pay Now"),
+      payNowUpgradeToSubscription: z41.string().optional().default("Upgrade to Subscription"),
+      quantity: z41.string().default("Quantity"),
+      /** This isn't configurable in the admin-nextjs editor */
+      recurringShipping: z41.string().optional().default("Recurring shipping"),
+      recurringSubtotal: z41.string().default("Recurring subtotal"),
+      reviewsPlural: z41.string().optional().default("Reviews"),
+      reviewsSingular: z41.string().optional().default("Review"),
+      save: z41.union([z41.string(), z41.unknown().transform(() => "Save")]).optional().default("Save"),
+      shipping: z41.string().default("Shipping"),
+      subscriptionOption: z41.string().optional().default("Subscribe and Save"),
+      subtotal: z41.string().default("Subtotal"),
+      taxes: z41.string().default("Taxes"),
+      total: z41.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: z41.string().optional().default("english")
+  }),
+  metafields: z41.boolean().default(false),
+  /** This isn't configurable in the admin-nextjs editor */
+  offer: z41.object({
+    count: z41.number().default(1)
+  }),
+  offersLayout: z41.object({
+    itemsPerPage: z41.number().optional(),
+    type: z41.enum(["list", "grid", "carousel"]).default("list")
+  }).optional().default({
+    type: "list"
+  }),
+  /** This isn't configurable in the admin-nextjs editor */
+  previewMode: z41.boolean().default(false),
+  productLimit: z41.number().optional().default(1),
+  productOptions: z41.object({
+    /** This isn't configurable in the admin-nextjs editor */
+    hideOutOfStockVariants: z41.boolean().optional().default(false),
+    matchVariant: z41.boolean().optional().default(true),
+    showDeclineAll: z41.enum(["above", "below", "both", "none"]).optional(),
+    showShipping: z41.boolean().optional().default(true),
+    showSubtotal: z41.boolean().optional().default(true),
+    showTaxes: z41.boolean().optional().default(true),
+    showTotal: z41.boolean().optional().default(true),
+    showVariantSelectors: z41.boolean().optional().default(true),
+    variantSelectorDisplayMode: z41.enum(["separate", "single"]).optional().default("separate")
+  }),
+  productType: z41.union([z41.enum(["one-time", "subscription", "both"]), z41.literal("").transform(() => "one-time")]).default("one-time"),
+  productTypeSelector: z41.enum(["dropdown", "radio"]).optional().default("radio"),
+  quantityInputs: z41.object({
+    defaultQuantity: z41.union([z41.number(), z41.null().transform(() => 1)]).default(1),
+    enabled: z41.boolean().default(true),
+    maxValue: z41.union([z41.number(), z41.null().transform(() => 15)]).default(15),
+    minValue: z41.union([z41.number().min(0), z41.unknown().transform(() => 0)]).default(1)
+  }),
+  shipping: z41.object({
+    amount: strictNumber.default(10),
+    /** This isn't configurable in the admin-nextjs editor */
+    enabled: z41.boolean().default(true),
+    title: z41.string().optional().default("Shipping Fees"),
+    type: z41.enum(["free", "fixed_amount"]).default("free")
+  }),
+  styles: z41.object({
+    starColor: z41.string().optional().default("#fadb14"),
+    starSize: z41.union([z41.enum(["small", "medium", "large"]), z41.unknown().transform(() => "large")]).optional().default("large"),
+    starStrokeColor: z41.string().optional().default("#fadb14"),
+    strokeWidth: z41.string().optional().default("1")
+  }).optional(),
+  subImages: z41.number().nullish().default(8),
+  subscription: z41.object({
+    discount: z41.object({
+      amount: strictNumber.default(30),
+      shouldShowSavingText: z41.boolean().optional().default(true),
+      type: z41.enum(["none", "fixed_amount", "percentage"]).default("none")
+    }),
+    shipping: z41.object({
+      amount: strictNumber.default(1),
+      /** This isn't configurable in the admin-nextjs editor */
+      enabled: z41.boolean().default(true),
+      /** This isn't configurable in the admin-nextjs editor */
+      recurringAmount: strictNumber.default(2),
+      shippingTitle: z41.string().default("Shipping Fees"),
+      type: z41.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: z41.boolean().optional(),
+  /** This isn't configurable in the admin-nextjs editor */
+  template: z41.string().optional().default(""),
+  type: z41.literal("shopify_post_purchase_extension").default("shopify_post_purchase_extension"),
+  upgradeToSubscription: z41.object({
+    acceptButtonText: z41.string().optional().default("Upgrade"),
+    allow: z41.boolean().optional().default(false),
+    emailRefundNotice: z41.boolean().optional().default(false),
+    errorBannerText: z41.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 = z42.union([z42.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: z42.unknown().default({}),
+  blocks: z42.array(z42.unknown()).optional(),
+  discount: PostPurchaseSettings.shape.discount.extend({ amount: amount.default(30) }),
+  integrations: z42.unknown().default({}),
+  shipping: PostPurchaseSettings.shape.shipping.extend({ amount: amount.default(10) }),
+  styles: z42.unknown().default({}),
+  subImages: PostPurchaseSettings.shape.subImages.catch(null),
+  subscription: z42.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 = z43.object({ type: z43.string() }).safeParse(overrides.discount);
+  if (discount.success && discount.data.type === "fixed") {
+    overrides.discount = { ...z43.record(z43.string(), z43.unknown()).parse(overrides.discount), type: "fixed_amount" };
+  }
+  const effective = PostPurchaseProductSettings.parse(merge({}, original, overrides));
+  return { data, effective, metadata, original };
+};
+
+// src/schema/postPurchasePlanCatalog.ts
+import { z as z46 } from "zod";
+
+// src/schema/postPurchasePlanAdjustment.ts
+import { z as z45 } from "zod";
+
+// src/schema/postPurchaseDiscount.ts
+import { z as z44 } from "zod";
+var Discount = z44.object({
+  amount: z44.number().nonnegative(),
+  title: z44.string(),
+  type: z44.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 = z45.object({
+  amount: PostPurchaseDiscount.shape.amount,
+  type: z45.enum(["percentage", "fixed_amount", "price"])
+}).refine(({ amount: amount2, type }) => type === "price" || validPostPurchaseDiscount({ amount: amount2, type }));
+
+// src/schema/postPurchasePlanCatalog.ts
+var PostPurchasePlanOption = z46.object({
+  adjustment: PostPurchasePlanAdjustment.optional(),
+  id: z46.number().int().positive(),
+  intervalFrequency: z46.string().regex(/^[1-9]\d*$/).optional(),
+  intervalLabel: z46.string().min(1),
+  name: z46.string().min(1)
+});
+var PostPurchasePlanCatalog = z46.object({
+  plans: z46.array(PostPurchasePlanOption),
+  productId: z46.number().int().positive(),
+  requiresSellingPlan: z46.boolean(),
+  variantId: z46.number().int().positive()
+});
+
+// src/server/postPurchaseLegacyPlans.ts
+import { z as z48 } from "zod";
+
+// src/server/postPurchasePlanAdjustment.ts
+import { z as z47 } from "zod";
+var SourceAdjustment = z47.object({
+  amount: PostPurchaseProductSettings.shape.discount.shape.amount.unwrap(),
+  type: z47.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: z48.string().regex(/^[1-9]\d*$/).nullish()
+});
+var Group = z48.object({
+  discountAmount: z48.unknown(),
+  discountType: z48.unknown(),
+  id: z48.number().int().positive(),
+  sellingPlans: z48.array(z48.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
+import { z as z49 } from "zod";
+var Groups = z49.array(
+  z49.object({
+    id: z49.string().min(1),
+    sellingPlans: z49.unknown()
+  })
+);
+var Allocations = z49.array(z49.object({ sellingPlanGroupId: z49.string().min(1) })).default([]);
+var Plans = z49.array(
+  PostPurchasePlanOption.pick({ id: true, name: true }).extend({
+    options: z49.array(z49.object({ value: z49.string().min(1) })).min(1),
+    priceAdjustments: z49.array(z49.unknown())
+  })
+);
+var FirstAdjustment = z49.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
+import { z as z54 } from "zod";
+
+// src/schema/postPurchaseProduct.ts
+import { z as z53 } from "zod";
+
+// src/schema/postPurchaseProductDisplay.ts
+import { z as z51 } from "zod";
+
+// src/schema/postPurchaseProductGallery.ts
+import { z as z50 } from "zod";
+var PostPurchaseProductGallery = z50.object({
+  images: z50.array(
+    z50.object({
+      description: z50.string(),
+      id: z50.number().int().positive(),
+      source: z50.string(),
+      thumbnail: z50.string()
+    })
+  ),
+  selectedImageId: z50.number().int().positive().optional()
+});
+
+// src/schema/postPurchaseProductDisplay.ts
+var language = PostPurchaseSettings.shape.language;
+var PostPurchasePrimaryImageSource = z51.string().default(
+  "https://cdn.shopify.com/shopifycloud/shopify/assets/no-image-2048-5e88c1b20e087fb7bbe9a3771824e743c244f437e4f8ba93bbf7b11b53f7824c.gif"
+);
+var PostPurchaseProductDisplay = z51.object({
+  discountedFrom: PostPurchaseSettings.shape.discountedFrom,
+  gallery: PostPurchaseProductGallery.optional(),
+  language: language.pick({
+    description: true,
+    descriptionEnabled: true,
+    descriptionRte: true,
+    descriptionSpacing: true
+  }),
+  primaryImage: z51.object({ description: z51.string(), source: z51.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
+import { z as z52 } from "zod";
+var PostPurchaseSubscriptionTerms = z52.object({
+  adjustment: PostPurchasePlanAdjustment.optional(),
+  initialShippingPrice: z52.number().nonnegative(),
+  intervalLabel: z52.string().min(1),
+  name: z52.string().min(1),
+  recurringShippingPrice: z52.number().nonnegative(),
+  shippingOption: z52.object({ presentmentTitle: z52.string(), title: z52.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 = z53.object({
+  display: PostPurchaseProductDisplay,
+  labels: z53.object({
+    declineAll: global.declineAll,
+    free: z53.string(),
+    payNow: z53.string(),
+    quantity: z53.string(),
+    recurringShipping: global.recurringShipping,
+    recurringSubtotal: global.recurringSubtotal,
+    save: z53.string(),
+    shipping: z53.string(),
+    subtotal: z53.string(),
+    taxes: z53.string(),
+    total: z53.string()
+  }),
+  product: OfferProduct.pick({ description: true, id: true, image: true, title: true }).extend({
+    description: OfferProduct.shape.description.nullable(),
+    id: PostPurchaseProductId,
+    variant: PostPurchaseVariant
+  }),
+  selection: z53.object({
+    productId: PostPurchaseProductId,
+    quantity: z53.number().int().positive(),
+    sellingPlanId: z53.number().int().positive().optional(),
+    variantId: PostPurchaseVariantId
+  }),
+  status: z53.literal("prepared"),
+  terms: z53.object({
+    discount: PostPurchaseDiscount,
+    shipping: z53.object({
+      amount: z53.number().nonnegative(),
+      title: z53.string(),
+      type: z53.enum(["free", "fixed_amount"])
+    }),
+    subscription: PostPurchaseSubscriptionTerms.optional()
+  })
+});
+var PostPurchasePreparation = z53.discriminatedUnion("status", [
+  PreparedPostPurchaseProduct,
+  z53.object({ reason: z53.string(), status: z53.literal("unsupported") })
+]);
+
+// src/schema/postPurchaseSubscriptionProduct.ts
+var PreparedPostPurchaseSubscription = PreparedPostPurchaseProduct.extend({
+  selection: PreparedPostPurchaseProduct.shape.selection.extend({ sellingPlanId: z54.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
+import { z as z55 } from "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 = z55.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
 import { chunk } from "es-toolkit";
 
@@ -5587,7 +6270,7 @@ var postAnalyticsEvents = async (input, ctx) => {
 };
 
 // src/server/requestSchemas.ts
-import { z as z39 } from "zod";
+import { z as z56 } from "zod";
 var REQUEST_BOUNDS = {
   /** Cart-level attributes per cart. */
   CART_ATTRIBUTES_MAX: 100,
@@ -5618,42 +6301,42 @@ var REQUEST_BOUNDS = {
   /** Rich ads transaction lines — the engine's ads contract. */
   TRANSACTION_ITEMS_MAX: 50
 };
-var KeyValue = z39.object({
-  key: z39.string().max(REQUEST_BOUNDS.STRING_KEY_MAX),
-  value: z39.string().max(REQUEST_BOUNDS.STRING_VALUE_MAX).optional()
+var KeyValue = z56.object({
+  key: z56.string().max(REQUEST_BOUNDS.STRING_KEY_MAX),
+  value: z56.string().max(REQUEST_BOUNDS.STRING_VALUE_MAX).optional()
 });
-var CartLineInputSchema = z39.object({
-  productId: z39.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
-  properties: z39.array(KeyValue).max(REQUEST_BOUNDS.LINE_PROPERTIES_MAX).optional(),
-  quantity: z39.number(),
-  subscriptionId: z39.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  variantId: z39.string().max(REQUEST_BOUNDS.STRING_ID_MAX)
+var CartLineInputSchema = z56.object({
+  productId: z56.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  properties: z56.array(KeyValue).max(REQUEST_BOUNDS.LINE_PROPERTIES_MAX).optional(),
+  quantity: z56.number(),
+  subscriptionId: z56.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  variantId: z56.string().max(REQUEST_BOUNDS.STRING_ID_MAX)
 });
-var CartInputSchema = z39.object({
-  attributes: z39.array(KeyValue).max(REQUEST_BOUNDS.CART_ATTRIBUTES_MAX).optional(),
+var CartInputSchema = z56.object({
+  attributes: z56.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: z39.number().optional(),
+  currencyRate: z56.number().optional(),
   /** Applied discount codes; the engine evaluates `discount_code` rules against them (sent as `[{code}]`). */
-  discountCodes: z39.array(z39.string().max(REQUEST_BOUNDS.STRING_KEY_MAX)).max(REQUEST_BOUNDS.DISCOUNT_CODES_MAX).optional(),
+  discountCodes: z56.array(z56.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: z39.number().optional(),
-  items: z39.array(CartLineInputSchema).max(REQUEST_BOUNDS.CART_ITEMS_MAX),
+  discountTotal: z56.number().optional(),
+  items: z56.array(CartLineInputSchema).max(REQUEST_BOUNDS.CART_ITEMS_MAX),
   /** Presentment subtotal in cents. */
-  subtotal: z39.number()
+  subtotal: z56.number()
 });
-var UserConfigInputSchema = z39.object({ shop: z39.string().max(REQUEST_BOUNDS.STRING_ID_MAX) });
-var DataSourceInputSchema = z39.object({
+var UserConfigInputSchema = z56.object({ shop: z56.string().max(REQUEST_BOUNDS.STRING_ID_MAX) });
+var DataSourceInputSchema = z56.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: z39.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  companyLocationId: z56.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
@@ -5662,16 +6345,16 @@ var DataSourceInputSchema = z39.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: z39.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: z39.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  dataSourcePath: z39.string().max(REQUEST_BOUNDS.STRING_KEY_MAX),
+  country: z56.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: z56.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  dataSourcePath: z56.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: z39.enum(["no", "yes"]).optional(),
-  integrations: z39.record(z39.string().max(REQUEST_BOUNDS.STRING_KEY_MAX), z39.boolean()).refine((record) => Object.keys(record).length <= REQUEST_BOUNDS.INTEGRATION_KEYS_MAX, {
+  filterInputs: z56.enum(["no", "yes"]).optional(),
+  integrations: z56.record(z56.string().max(REQUEST_BOUNDS.STRING_KEY_MAX), z56.boolean()).refine((record) => Object.keys(record).length <= REQUEST_BOUNDS.INTEGRATION_KEYS_MAX, {
     message: `Too many integration keys (max ${REQUEST_BOUNDS.INTEGRATION_KEYS_MAX})`
   }).optional(),
   /**
@@ -5684,31 +6367,31 @@ var DataSourceInputSchema = z39.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: z39.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: z39.number().max(REQUEST_BOUNDS.LIMIT_MAX),
-  productType: z39.enum(["both", "one-time", "subscription"]).optional(),
-  shop: z39.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
-  visitorId: z39.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
-});
-var GiftInputSchema = z39.object({
-  cost: z39.number(),
-  discounted: z39.boolean(),
+  language: z56.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: z56.number().max(REQUEST_BOUNDS.LIMIT_MAX),
+  productType: z56.enum(["both", "one-time", "subscription"]).optional(),
+  shop: z56.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  visitorId: z56.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
+});
+var GiftInputSchema = z56.object({
+  cost: z56.number(),
+  discounted: z56.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: z39.enum(GIFT_KINDS).default("gwp"),
-  lineId: z39.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
-  productId: z39.number(),
+  kind: z56.enum(GIFT_KINDS).default("gwp"),
+  lineId: z56.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  productId: z56.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: z39.number().int().min(1).default(1),
-  widgetId: z39.number()
+  quantity: z56.number().int().min(1).default(1),
+  widgetId: z56.number()
 });
-var GiftValidationInputSchema = z39.object({
+var GiftValidationInputSchema = z56.object({
   cart: CartInputSchema,
   /**
    * Buyer's market country — threaded into the per-widget data-source evaluations, which forward it to
@@ -5717,25 +6400,25 @@ var GiftValidationInputSchema = z39.object({
    * turns markets off); regex-bound and uppercase-normalized for the same reasons as
    * `DataSourceInputSchema`'s `country`.
    */
-  country: z39.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: z39.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  gifts: z39.array(GiftInputSchema).max(REQUEST_BOUNDS.GIFTS_MAX),
+  country: z56.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: z56.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  gifts: z56.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: z39.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: z39.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
-  visitorId: z39.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
+  language: z56.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: z56.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  visitorId: z56.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
 });
-var GiftAdjustmentSchema = z39.object({
-  lineId: z39.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
-  quantity: z39.number().int().nonnegative()
+var GiftAdjustmentSchema = z56.object({
+  lineId: z56.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  quantity: z56.number().int().nonnegative()
 });
-var GiftValidationResponseSchema = z39.object({
-  adjust: z39.array(GiftAdjustmentSchema).max(REQUEST_BOUNDS.GIFTS_MAX).default([]),
-  remove: z39.array(z39.string().max(REQUEST_BOUNDS.STRING_ID_MAX)).max(REQUEST_BOUNDS.GIFTS_MAX).refine(
+var GiftValidationResponseSchema = z56.object({
+  adjust: z56.array(GiftAdjustmentSchema).max(REQUEST_BOUNDS.GIFTS_MAX).default([]),
+  remove: z56.array(z56.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`"
   )
@@ -5746,47 +6429,47 @@ var GiftValidationResponseSchema = z39.object({
   ({ adjust }) => new Set(adjust.map(({ lineId }) => lineId)).size === adjust.length,
   "a line id may appear at most once in `adjust`"
 );
-var MonetizeTransactionItemSchema = z39.object({
-  id: z39.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
-  priceCents: z39.number(),
-  quantity: z39.number(),
-  title: z39.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX),
-  type: z39.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX)
-});
-var MonetizeInputSchema = z39.object({
+var MonetizeTransactionItemSchema = z56.object({
+  id: z56.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  priceCents: z56.number(),
+  quantity: z56.number(),
+  title: z56.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX),
+  type: z56.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX)
+});
+var MonetizeInputSchema = z56.object({
   cart: CartInputSchema,
   /** Client-minted render-beacon correlation id; forwarded to the ads engine as `client_request_id`. */
-  clientRequestId: z39.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  country: z39.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  currency: z39.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  clientRequestId: z56.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  country: z56.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  currency: z56.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
   /** Ads-targeting identity/geo/locale fields (React parity); folded into the engine query verbatim. */
-  customerEmail: z39.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
-  customerFirstName: z39.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
-  customerId: z39.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  customerLastName: z39.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
-  language: z39.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  customerEmail: z56.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
+  customerFirstName: z56.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
+  customerId: z56.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  customerLastName: z56.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
+  language: z56.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
   /** Buyer-facing order name (e.g. `#1001`) for the server-composed "Order … Confirmed" chrome line. */
-  orderName: z39.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
+  orderName: z56.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: z39.enum(["customer_account", "order_status", "thank_you_page"]),
+  placement: z56.enum(["customer_account", "order_status", "thank_you_page"]),
   /** Privacy Policy footer href — the Monetize widget's `privacy_policy_url` setting (React parity). */
-  privacyPolicyUrl: z39.string().max(REQUEST_BOUNDS.STRING_URL_MAX).optional(),
+  privacyPolicyUrl: z56.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: z39.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  shop: z39.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  sessionId: z56.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  shop: z56.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: z39.boolean().optional(),
-  timezone: z39.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  testing: z56.boolean().optional(),
+  timezone: z56.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
   /** Decorated (numeric) order id → the ads `transaction_id`. */
-  transactionId: z39.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  transactionId: z56.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: z39.array(MonetizeTransactionItemSchema).max(REQUEST_BOUNDS.TRANSACTION_ITEMS_MAX).optional(),
+  transactionItems: z56.array(MonetizeTransactionItemSchema).max(REQUEST_BOUNDS.TRANSACTION_ITEMS_MAX).optional(),
   /** Order total in presentment cents (React prefers total over subtotal); else `cart.subtotal`. */
-  transactionTotal: z39.number().optional(),
-  visitorId: z39.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  zipCode: z39.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
+  transactionTotal: z56.number().optional(),
+  visitorId: z56.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  zipCode: z56.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
 });
-var WidgetSettingsInputSchema = z39.object({
+var WidgetSettingsInputSchema = z56.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
@@ -5794,9 +6477,9 @@ var WidgetSettingsInputSchema = z39.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: z39.number().int().positive().optional().catch(void 0),
-  id: z39.number(),
-  key: z39.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  cacheKey: z56.number().int().positive().optional().catch(void 0),
+  id: z56.number(),
+  key: z56.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`
@@ -5805,36 +6488,36 @@ var WidgetSettingsInputSchema = z39.object({
    * `privacyPolicyUrl` comes from the widget settings server-side (more authoritative than a relay).
    */
   monetize: MonetizeInputSchema.omit({ privacyPolicyUrl: true, shop: true }).optional(),
-  shop: z39.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  shop: z56.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
   /** Stable per-buyer id; when present, enables sticky server-side A/B variant selection. */
-  visitorId: z39.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
+  visitorId: z56.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
 });
-var AnalyticsEventInputSchema = z39.object({
-  name: z39.string().max(REQUEST_BOUNDS.STRING_KEY_MAX),
-  properties: z39.record(z39.string().max(REQUEST_BOUNDS.STRING_KEY_MAX), z39.unknown()).optional(),
-  sentAt: z39.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
+var AnalyticsEventInputSchema = z56.object({
+  name: z56.string().max(REQUEST_BOUNDS.STRING_KEY_MAX),
+  properties: z56.record(z56.string().max(REQUEST_BOUNDS.STRING_KEY_MAX), z56.unknown()).optional(),
+  sentAt: z56.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
 });
-var AnalyticsSegmentsInputSchema = z39.object({
-  device: z39.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional().catch(void 0),
-  source: z39.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional().catch(void 0),
-  visitor: z39.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional().catch(void 0)
+var AnalyticsSegmentsInputSchema = z56.object({
+  device: z56.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional().catch(void 0),
+  source: z56.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional().catch(void 0),
+  visitor: z56.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional().catch(void 0)
 });
-var AnalyticsInputSchema = z39.object({
+var AnalyticsInputSchema = z56.object({
   /** Rebuy cart token (the `r_cart_token` cart attribute), when available — primary aggregation key. */
-  cartToken: z39.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  cartToken: z56.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
   /** Shopify checkout token, when available — drives cart/checkout aggregation downstream. */
-  checkoutToken: z39.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  events: z39.array(AnalyticsEventInputSchema).max(REQUEST_BOUNDS.EVENTS_MAX),
+  checkoutToken: z56.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  events: z56.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: z39.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
-  visitorId: z39.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  shop: z56.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  visitorId: z56.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
   /** The widget id (smartBlockId) the events belong to. */
-  widgetId: z39.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
+  widgetId: z56.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
 });
 export {
   AnalyticsEventInputSchema,
@@ -5861,6 +6544,7 @@ export {
   fetchMonetizeOffers,
   fetchUserConfig,
   postAnalyticsEvents,
+  preparePostPurchaseSubscription,
   translateAnalyticsEvent,
   validateGifts
 };