@rebuy/rebuy 3.54.0 → 3.55.0

package/dist/server/index.cjs

@@ -64,6 +64,7 @@ __export(server_exports, {
   preparePostPurchaseSubscription: () => preparePostPurchaseSubscription,
   preparePostPurchaseView: () => preparePostPurchaseView,
   readPostPurchaseGroupSelection: () => readPostPurchaseGroupSelection,
+  readPostPurchaseProductSource: () => readPostPurchaseProductSource,
   readPostPurchaseQuantity: () => readPostPurchaseQuantity,
   translateAnalyticsEvent: () => translateAnalyticsEvent,
   validateGifts: () => validateGifts
@@ -6080,7 +6081,7 @@ var validateGifts = async (input, ctx) => {
 
 // src/server/normalizePostPurchaseProduct.ts
 var import_compat7 = require("es-toolkit/compat");
-var import_zod45 = require("zod");
+var import_zod46 = require("zod");
 
 // src/schema/postPurchaseProductSettings.ts
 var import_zod44 = require("zod");
@@ -6161,18 +6162,54 @@ var PostPurchaseProductSettings = PostPurchaseSettings.pick({
   subscription: import_zod44.z.unknown().default(PostPurchaseSettings.shape.subscription.parse(void 0))
 });
 
+// src/server/readPostPurchaseProductSource.ts
+var import_zod45 = require("zod");
+var Envelope = PostPurchaseProductSource.extend({ data: import_zod45.z.array(import_zod45.z.unknown()) });
+var Product3 = PostPurchaseProductSource.shape.data.element;
+var Identified = import_zod45.z.object({ id: PostPurchaseProductId });
+var heard = /* @__PURE__ */ new WeakMap();
+var firstHearing = (response, report) => {
+  const reporters = heard.get(response) ?? /* @__PURE__ */ new WeakSet();
+  heard.set(response, reporters);
+  if (reporters.has(report)) return false;
+  reporters.add(report);
+  return true;
+};
+var readPostPurchaseProductSource = (response, report) => {
+  const { data, metadata } = Envelope.parse(deepCamelCase(response));
+  const drift = [];
+  const dropped = [];
+  const products = data.flatMap((raw, productIndex) => {
+    const parsed = Product3.safeParse(raw);
+    if (parsed.success) return [{ product: parsed.data, productIndex }];
+    const id = Identified.safeParse(raw);
+    const issues = parsed.error.issues.map((issue) => ({ ...issue, path: ["data", productIndex, ...issue.path] }));
+    const path = issues[0].path.join(".");
+    dropped.push({ issues, productIndex });
+    drift.push({
+      detail: `Dropped post-purchase product${id.success ? ` ${id.data.id}` : ""}: ${path}`,
+      kind: "product"
+    });
+    return [];
+  });
+  if (report && drift.length && firstHearing(response, report)) drift.forEach((event) => report(event));
+  return { dropped, metadata, products };
+};
+
 // src/server/normalizePostPurchaseProduct.ts
-var normalizePostPurchaseProduct = (settings, response) => {
+var normalizePostPurchaseSource = (settings, response, report) => {
   const original = PostPurchaseProductSettings.parse(deepCamelCase(settings));
-  const { data, metadata } = PostPurchaseProductSource.parse(deepCamelCase(response));
+  const { dropped, metadata, products } = readPostPurchaseProductSource(response, report);
   const overrides = Object.fromEntries(Object.entries(metadata.widget).filter(([key]) => key in original));
-  const discount = import_zod45.z.object({ type: import_zod45.z.string() }).safeParse(overrides.discount);
+  const discount = import_zod46.z.object({ type: import_zod46.z.string() }).safeParse(overrides.discount);
   if (discount.success && discount.data.type === "fixed") {
-    overrides.discount = { ...import_zod45.z.record(import_zod45.z.string(), import_zod45.z.unknown()).parse(overrides.discount), type: "fixed_amount" };
+    overrides.discount = { ...import_zod46.z.record(import_zod46.z.string(), import_zod46.z.unknown()).parse(overrides.discount), type: "fixed_amount" };
   }
   const effective = PostPurchaseProductSettings.parse((0, import_compat7.merge)({}, original, overrides));
-  return { data, effective, metadata, original };
+  const data = products.map(({ product }) => product);
+  return { dropped, normalized: { data, effective, metadata, original }, products };
 };
+var normalizePostPurchaseProduct = (settings, response, report) => normalizePostPurchaseSource(settings, response, report).normalized;
 
 // src/pricing/amountToCents.ts
 var round = (value, precision = 0) => {
@@ -6197,52 +6234,52 @@ var postPurchasePlanDiscountPercentage = (price, adjustment) => {
 };
 
 // src/schema/postPurchasePlanCatalog.ts
-var import_zod48 = require("zod");
+var import_zod49 = require("zod");
 
 // src/schema/postPurchasePlanAdjustment.ts
-var import_zod47 = require("zod");
+var import_zod48 = require("zod");
 
 // src/schema/postPurchaseDiscount.ts
-var import_zod46 = require("zod");
-var Discount = import_zod46.z.object({
-  amount: import_zod46.z.number().nonnegative(),
-  title: import_zod46.z.string(),
-  type: import_zod46.z.enum(["none", "fixed_amount", "percentage"])
+var import_zod47 = require("zod");
+var Discount = import_zod47.z.object({
+  amount: import_zod47.z.number().nonnegative(),
+  title: import_zod47.z.string(),
+  type: import_zod47.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_zod47.z.object({
+var PostPurchasePlanAdjustment = import_zod48.z.object({
   amount: PostPurchaseDiscount.shape.amount,
-  type: import_zod47.z.enum(["percentage", "fixed_amount", "price"])
+  type: import_zod48.z.enum(["percentage", "fixed_amount", "price"])
 }).refine(({ amount: amount2, type }) => type === "price" || validPostPurchaseDiscount({ amount: amount2, type }));
 
 // src/schema/postPurchasePlanCatalog.ts
-var PostPurchasePlanOption = import_zod48.z.object({
+var PostPurchasePlanOption = import_zod49.z.object({
   adjustment: PostPurchasePlanAdjustment.optional(),
   /** cab-checkout's `discountPercentage`: the plan's own whole-percent saving on the regular price (`{{subscriptionDiscount}}`). */
-  discountPercentage: import_zod48.z.number().int().min(0).max(100).optional(),
-  id: import_zod48.z.number().int().positive(),
-  intervalFrequency: import_zod48.z.string().regex(/^[1-9]\d*$/).optional(),
-  intervalLabel: import_zod48.z.string().min(1),
-  name: import_zod48.z.string().min(1)
+  discountPercentage: import_zod49.z.number().int().min(0).max(100).optional(),
+  id: import_zod49.z.number().int().positive(),
+  intervalFrequency: import_zod49.z.string().regex(/^[1-9]\d*$/).optional(),
+  intervalLabel: import_zod49.z.string().min(1),
+  name: import_zod49.z.string().min(1)
 });
-var PostPurchasePlanCatalog = import_zod48.z.object({
-  plans: import_zod48.z.array(PostPurchasePlanOption),
-  productId: import_zod48.z.number().int().positive(),
-  requiresSellingPlan: import_zod48.z.boolean(),
-  variantId: import_zod48.z.number().int().positive()
+var PostPurchasePlanCatalog = import_zod49.z.object({
+  plans: import_zod49.z.array(PostPurchasePlanOption),
+  productId: import_zod49.z.number().int().positive(),
+  requiresSellingPlan: import_zod49.z.boolean(),
+  variantId: import_zod49.z.number().int().positive()
 });
 
 // src/server/postPurchaseLegacyPlans.ts
-var import_zod50 = require("zod");
+var import_zod51 = require("zod");
 
 // src/server/postPurchasePlanAdjustment.ts
-var import_zod49 = require("zod");
-var SourceAdjustment = import_zod49.z.object({
+var import_zod50 = require("zod");
+var SourceAdjustment = import_zod50.z.object({
   amount: PostPurchaseProductSettings.shape.discount.shape.amount.unwrap(),
-  type: import_zod49.z.enum(["percentage", "fixed_amount", "amount", "price", "none", "fixed"])
+  type: import_zod50.z.enum(["percentage", "fixed_amount", "amount", "price", "none", "fixed"])
 });
 var readPostPurchasePlanAdjustment = (raw) => {
   const source2 = SourceAdjustment.parse(raw);
@@ -6261,13 +6298,13 @@ var readPostPurchasePlanAdjustment = (raw) => {
 var Plan = PostPurchasePlanOption.pick({ id: true, name: true }).extend({
   orderIntervalFrequency: PostPurchasePlanOption.shape.intervalFrequency.unwrap(),
   orderIntervalUnitType: PostPurchasePlanOption.shape.intervalLabel,
-  shopifyVariantId: import_zod50.z.string().regex(/^[1-9]\d*$/).nullish()
+  shopifyVariantId: import_zod51.z.string().regex(/^[1-9]\d*$/).nullish()
 });
-var Group = import_zod50.z.object({
-  discountAmount: import_zod50.z.unknown(),
-  discountType: import_zod50.z.unknown(),
-  id: import_zod50.z.number().int().positive(),
-  sellingPlans: import_zod50.z.array(import_zod50.z.object({ shopifyVariantId: Plan.shape.shopifyVariantId }).passthrough())
+var Group = import_zod51.z.object({
+  discountAmount: import_zod51.z.unknown(),
+  discountType: import_zod51.z.unknown(),
+  id: import_zod51.z.number().int().positive(),
+  sellingPlans: import_zod51.z.array(import_zod51.z.object({ shopifyVariantId: Plan.shape.shopifyVariantId }).passthrough())
 });
 var readPostPurchaseLegacyPlans = (raw, variantId) => {
   const group = Group.pick({ id: true, sellingPlans: true }).parse(raw);
@@ -6288,21 +6325,21 @@ var readPostPurchaseLegacyPlans = (raw, variantId) => {
 };
 
 // src/server/postPurchaseModernPlans.ts
-var import_zod51 = require("zod");
-var Groups = import_zod51.z.array(
-  import_zod51.z.object({
-    id: import_zod51.z.string().min(1),
-    sellingPlans: import_zod51.z.unknown()
+var import_zod52 = require("zod");
+var Groups = import_zod52.z.array(
+  import_zod52.z.object({
+    id: import_zod52.z.string().min(1),
+    sellingPlans: import_zod52.z.unknown()
   })
 );
-var Allocations = import_zod51.z.array(import_zod51.z.object({ sellingPlanGroupId: import_zod51.z.string().min(1) })).default([]);
-var Plans = import_zod51.z.array(
+var Allocations = import_zod52.z.array(import_zod52.z.object({ sellingPlanGroupId: import_zod52.z.string().min(1) })).default([]);
+var Plans = import_zod52.z.array(
   PostPurchasePlanOption.pick({ id: true, name: true }).extend({
-    options: import_zod51.z.array(import_zod51.z.object({ value: import_zod51.z.string().min(1) })).min(1),
-    priceAdjustments: import_zod51.z.array(import_zod51.z.unknown())
+    options: import_zod52.z.array(import_zod52.z.object({ value: import_zod52.z.string().min(1) })).min(1),
+    priceAdjustments: import_zod52.z.array(import_zod52.z.unknown())
   })
 );
-var FirstAdjustment = import_zod51.z.object({
+var FirstAdjustment = import_zod52.z.object({
   value: PostPurchaseProductSettings.shape.discount.shape.amount.unwrap(),
   valueType: PostPurchasePlanAdjustment.shape.type
 });
@@ -6325,8 +6362,9 @@ var readPostPurchaseModernPlans = (raw, allocations) => {
 
 // src/server/postPurchasePlanCatalog.ts
 var projectPostPurchasePlanCatalog = (normalized, report) => {
+  const { data } = normalized;
+  if (data.length === 1 && data[0].variants.length > 1) return null;
   try {
-    const { data } = normalized;
     if (data.length !== 1 || data[0].variants.length !== 1) throw new Error("Ambiguous product");
     const product = data[0];
     const variant2 = product.variants[0];
@@ -6357,72 +6395,72 @@ var projectPostPurchasePlanCatalog = (normalized, report) => {
 };
 
 // src/schema/postPurchaseSubscriptionProduct.ts
-var import_zod57 = require("zod");
+var import_zod58 = require("zod");
 
 // src/schema/postPurchaseProduct.ts
-var import_zod56 = require("zod");
+var import_zod57 = require("zod");
 
 // src/schema/postPurchaseProductDisplay.ts
-var import_zod54 = require("zod");
+var import_zod55 = require("zod");
 
 // src/schema/postPurchaseProductGallery.ts
-var import_zod52 = require("zod");
-var PostPurchaseProductGallery = import_zod52.z.object({
+var import_zod53 = require("zod");
+var PostPurchaseProductGallery = import_zod53.z.object({
   /**
    * Show the thumbnail row: the product had more than one image before `images` was capped at the
    * sub-image limit, and that limit allows at least one thumbnail. It stays true when the cap leaves one
    * image (legacy checks the count before slicing). Older replies omit it; fall back to `images.length > 1`.
    */
-  hasMultiple: import_zod52.z.boolean().optional(),
-  images: import_zod52.z.array(
-    import_zod52.z.object({
-      description: import_zod52.z.string(),
-      id: import_zod52.z.number().int().positive(),
-      source: import_zod52.z.string(),
-      thumbnail: import_zod52.z.string()
+  hasMultiple: import_zod53.z.boolean().optional(),
+  images: import_zod53.z.array(
+    import_zod53.z.object({
+      description: import_zod53.z.string(),
+      id: import_zod53.z.number().int().positive(),
+      source: import_zod53.z.string(),
+      thumbnail: import_zod53.z.string()
     })
   ),
-  selectedImageId: import_zod52.z.number().int().positive().optional()
+  selectedImageId: import_zod53.z.number().int().positive().optional()
 });
 
 // src/schema/postPurchaseProductReviews.ts
-var import_zod53 = require("zod");
-var decimal = import_zod53.z.union([
-  import_zod53.z.number(),
-  import_zod53.z.string().regex(/^\d+(?:\.\d+)?$/).transform(Number)
+var import_zod54 = require("zod");
+var decimal = import_zod54.z.union([
+  import_zod54.z.number(),
+  import_zod54.z.string().regex(/^\d+(?:\.\d+)?$/).transform(Number)
 ]);
-var PostPurchaseCommonReviewRating = import_zod53.z.object({ value: decimal.pipe(import_zod53.z.number().min(0).max(5)) });
+var PostPurchaseCommonReviewRating = import_zod54.z.object({ value: decimal.pipe(import_zod54.z.number().min(0).max(5)) });
 var PostPurchaseKlaviyoReviewRating = PostPurchaseCommonReviewRating.extend({
   // Legacy validates key presence, then displays the raw value on five stars without rescaling.
-  scale_max: import_zod53.z.unknown().nonoptional(),
-  scale_min: import_zod53.z.unknown().nonoptional()
+  scale_max: import_zod54.z.unknown().nonoptional(),
+  scale_min: import_zod54.z.unknown().nonoptional()
 });
-var PostPurchaseReviewCount = import_zod53.z.string().regex(/^\d+(?:\.\d+)?$/).transform(Number).pipe(import_zod53.z.number().int().nonnegative());
+var PostPurchaseReviewCount = import_zod54.z.string().regex(/^\d+(?:\.\d+)?$/).transform(Number).pipe(import_zod54.z.number().int().nonnegative());
 var PostPurchaseReviewStyles = PostPurchaseSettings.shape.styles.unwrap().extend({
-  strokeWidth: decimal.pipe(import_zod53.z.number().nonnegative()).default(1)
+  strokeWidth: decimal.pipe(import_zod54.z.number().nonnegative()).default(1)
 }).prefault({});
-var PostPurchaseProductReviews = import_zod53.z.object({
-  color: import_zod53.z.string(),
-  rating: import_zod53.z.number().positive().max(5),
-  reviewCount: import_zod53.z.number().int().nonnegative(),
-  reviewsPlural: import_zod53.z.string(),
-  reviewsSingular: import_zod53.z.string(),
-  size: import_zod53.z.enum(["small", "medium", "large"]),
-  strokeColor: import_zod53.z.string(),
-  strokeWidth: import_zod53.z.number().nonnegative()
+var PostPurchaseProductReviews = import_zod54.z.object({
+  color: import_zod54.z.string(),
+  rating: import_zod54.z.number().positive().max(5),
+  reviewCount: import_zod54.z.number().int().nonnegative(),
+  reviewsPlural: import_zod54.z.string(),
+  reviewsSingular: import_zod54.z.string(),
+  size: import_zod54.z.enum(["small", "medium", "large"]),
+  strokeColor: import_zod54.z.string(),
+  strokeWidth: import_zod54.z.number().nonnegative()
 });
 
 // src/schema/postPurchaseProductDisplay.ts
 var language = PostPurchaseSettings.shape.language;
-var PostPurchasePrimaryImageSource = import_zod54.z.string().default(
+var PostPurchasePrimaryImageSource = import_zod55.z.string().default(
   "https://cdn.shopify.com/shopifycloud/shopify/assets/no-image-2048-5e88c1b20e087fb7bbe9a3771824e743c244f437e4f8ba93bbf7b11b53f7824c.gif"
 );
-var PostPurchaseProductDisplay = import_zod54.z.object({
+var PostPurchaseProductDisplay = import_zod55.z.object({
   descriptionDocument: TiptapDocument.optional(),
   discountedFrom: PostPurchaseSettings.shape.discountedFrom,
   gallery: PostPurchaseProductGallery.optional(),
   language: language.pick({ description: true, descriptionEnabled: true }),
-  primaryImage: import_zod54.z.object({ description: import_zod54.z.string(), source: import_zod54.z.string() }),
+  primaryImage: import_zod55.z.object({ description: import_zod55.z.string(), source: import_zod55.z.string() }),
   productOptions: PostPurchaseSettings.shape.productOptions.pick({
     showDeclineAll: true,
     showShipping: true,
@@ -6437,14 +6475,14 @@ var PostPurchaseProductDisplay = import_zod54.z.object({
 });
 
 // src/schema/postPurchaseSubscription.ts
-var import_zod55 = require("zod");
-var PostPurchaseSubscriptionTerms = import_zod55.z.object({
+var import_zod56 = require("zod");
+var PostPurchaseSubscriptionTerms = import_zod56.z.object({
   adjustment: PostPurchasePlanAdjustment.optional(),
-  initialShippingPrice: import_zod55.z.number().nonnegative(),
-  intervalLabel: import_zod55.z.string().min(1),
-  name: import_zod55.z.string().min(1),
-  recurringShippingPrice: import_zod55.z.number().nonnegative(),
-  shippingOption: import_zod55.z.object({ presentmentTitle: import_zod55.z.string(), title: import_zod55.z.string() })
+  initialShippingPrice: import_zod56.z.number().nonnegative(),
+  intervalLabel: import_zod56.z.string().min(1),
+  name: import_zod56.z.string().min(1),
+  recurringShippingPrice: import_zod56.z.number().nonnegative(),
+  shippingOption: import_zod56.z.object({ presentmentTitle: import_zod56.z.string(), title: import_zod56.z.string() })
 });
 
 // src/schema/postPurchaseProduct.ts
@@ -6454,52 +6492,52 @@ var PostPurchaseVariant = OfferProduct.shape.variants.element.pick({ id: true, t
   id: PostPurchaseVariantId,
   price: PostPurchaseAmount
 });
-var PreparedPostPurchaseProduct = import_zod56.z.object({
+var PreparedPostPurchaseProduct = import_zod57.z.object({
   display: PostPurchaseProductDisplay,
-  labels: import_zod56.z.object({
+  labels: import_zod57.z.object({
     declineAll: global.declineAll,
-    free: import_zod56.z.string(),
+    free: import_zod57.z.string(),
     notAvailable: global.notAvailable,
-    payNow: import_zod56.z.string(),
-    quantity: import_zod56.z.string(),
+    payNow: import_zod57.z.string(),
+    quantity: import_zod57.z.string(),
     recurringShipping: global.recurringShipping,
     recurringSubtotal: global.recurringSubtotal,
-    save: import_zod56.z.string(),
-    shipping: import_zod56.z.string(),
-    subtotal: import_zod56.z.string(),
-    taxes: import_zod56.z.string(),
-    total: import_zod56.z.string()
+    save: import_zod57.z.string(),
+    shipping: import_zod57.z.string(),
+    subtotal: import_zod57.z.string(),
+    taxes: import_zod57.z.string(),
+    total: import_zod57.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_zod56.z.object({
+  selection: import_zod57.z.object({
     productId: PostPurchaseProductId,
-    quantity: import_zod56.z.number().int().positive(),
-    sellingPlanId: import_zod56.z.number().int().positive().optional(),
+    quantity: import_zod57.z.number().int().positive(),
+    sellingPlanId: import_zod57.z.number().int().positive().optional(),
     variantId: PostPurchaseVariantId
   }),
-  status: import_zod56.z.literal("prepared"),
-  terms: import_zod56.z.object({
+  status: import_zod57.z.literal("prepared"),
+  terms: import_zod57.z.object({
     discount: PostPurchaseDiscount,
-    shipping: import_zod56.z.object({
-      amount: import_zod56.z.number().nonnegative(),
-      title: import_zod56.z.string(),
-      type: import_zod56.z.enum(["free", "fixed_amount"])
+    shipping: import_zod57.z.object({
+      amount: import_zod57.z.number().nonnegative(),
+      title: import_zod57.z.string(),
+      type: import_zod57.z.enum(["free", "fixed_amount"])
     }),
     subscription: PostPurchaseSubscriptionTerms.optional()
   })
 });
-var PostPurchasePreparation = import_zod56.z.discriminatedUnion("status", [
+var PostPurchasePreparation = import_zod57.z.discriminatedUnion("status", [
   PreparedPostPurchaseProduct,
-  import_zod56.z.object({ reason: import_zod56.z.string(), status: import_zod56.z.literal("unsupported") })
+  import_zod57.z.object({ reason: import_zod57.z.string(), status: import_zod57.z.literal("unsupported") })
 ]);
 
 // src/schema/postPurchaseSubscriptionProduct.ts
 var PreparedPostPurchaseSubscription = PreparedPostPurchaseProduct.extend({
-  selection: PreparedPostPurchaseProduct.shape.selection.extend({ sellingPlanId: import_zod57.z.number().int().positive() }),
+  selection: PreparedPostPurchaseProduct.shape.selection.extend({ sellingPlanId: import_zod58.z.number().int().positive() }),
   terms: PreparedPostPurchaseProduct.shape.terms.extend({
     subscription: PostPurchaseSubscriptionTerms
   }).refine(
@@ -6558,7 +6596,7 @@ var subscriptionUnavailable = (normalized, plan, allowCollection, quantity3) =>
 };
 
 // src/server/postPurchaseProductDisplay.ts
-var import_zod59 = require("zod");
+var import_zod60 = require("zod");
 
 // src/server/postPurchasePrimaryImage.ts
 var postPurchasePrimaryImage = (product) => {
@@ -6584,7 +6622,7 @@ var postPurchaseProductGallery = (product, limit) => {
 };
 
 // src/transforms/postPurchase/convertDescriptionRte.ts
-var import_zod58 = require("zod");
+var import_zod59 = require("zod");
 var alignments = { center: "center", left: "start", right: "end" };
 var colors = ["critical", "subdued", "success", "warning"];
 var sizes2 = ["extraSmall", "small", "medium", "large", "extraLarge"];
@@ -6596,19 +6634,19 @@ var spacings2 = {
   xloose: "extraLoose",
   xtight: "extraTight"
 };
-var Block = import_zod58.z.object({
-  attrs: import_zod58.z.object({ alignment: import_zod58.z.enum(["left", "center", "right"]).optional().catch(void 0) }).catch({}),
-  content: import_zod58.z.array(import_zod58.z.unknown()).catch([]),
-  type: import_zod58.z.literal("ShopifyTextBlock")
-});
-var Run = import_zod58.z.object({ marks: import_zod58.z.array(import_zod58.z.unknown()).catch([]), text: import_zod58.z.string().min(1), type: import_zod58.z.literal("text") });
-var Inline = import_zod58.z.object({
-  attrs: import_zod58.z.object({
-    color: import_zod58.z.enum(colors).optional().catch(void 0),
-    emphasis: import_zod58.z.array(import_zod58.z.unknown()).catch([]),
-    size: import_zod58.z.enum(sizes2).optional().catch(void 0)
+var Block = import_zod59.z.object({
+  attrs: import_zod59.z.object({ alignment: import_zod59.z.enum(["left", "center", "right"]).optional().catch(void 0) }).catch({}),
+  content: import_zod59.z.array(import_zod59.z.unknown()).catch([]),
+  type: import_zod59.z.literal("ShopifyTextBlock")
+});
+var Run = import_zod59.z.object({ marks: import_zod59.z.array(import_zod59.z.unknown()).catch([]), text: import_zod59.z.string().min(1), type: import_zod59.z.literal("text") });
+var Inline = import_zod59.z.object({
+  attrs: import_zod59.z.object({
+    color: import_zod59.z.enum(colors).optional().catch(void 0),
+    emphasis: import_zod59.z.array(import_zod59.z.unknown()).catch([]),
+    size: import_zod59.z.enum(sizes2).optional().catch(void 0)
   }),
-  type: import_zod58.z.literal("ShopifyTextInline")
+  type: import_zod59.z.literal("ShopifyTextInline")
 });
 var marks = (raw) => {
   const found = raw.map((mark) => Inline.safeParse(mark)).find(({ success }) => success)?.data;
@@ -6641,7 +6679,7 @@ var convertDescriptionRte = (rte, spacing) => TiptapDocument.parse({
 });
 
 // src/server/postPurchaseProductDisplay.ts
-var ResponseLanguage = import_zod59.z.object({ description: PostPurchaseProductDisplay.shape.responseDescription }).default({ description: "" });
+var ResponseLanguage = import_zod60.z.object({ description: PostPurchaseProductDisplay.shape.responseDescription }).default({ description: "" });
 var projectPostPurchaseProductDisplay = (effective, metadata, product) => PostPurchaseProductDisplay.parse({
   descriptionDocument: effective.language.descriptionRte && convertDescriptionRte(effective.language.descriptionRte, effective.language.descriptionSpacing),
   discountedFrom: effective.discountedFrom,
@@ -6654,16 +6692,16 @@ var projectPostPurchaseProductDisplay = (effective, metadata, product) => PostPu
 });
 
 // src/server/postPurchaseReviewData.ts
-var import_zod64 = require("zod");
+var import_zod65 = require("zod");
 
 // src/server/postPurchaseJudgeMeReviews.ts
-var import_zod61 = require("zod");
+var import_zod62 = require("zod");
 
 // src/server/postPurchaseReviewFields.ts
-var import_zod60 = require("zod");
-var Field = import_zod60.z.object({ key: import_zod60.z.string(), namespace: import_zod60.z.string(), value: import_zod60.z.unknown().optional() });
+var import_zod61 = require("zod");
+var Field = import_zod61.z.object({ key: import_zod61.z.string(), namespace: import_zod61.z.string(), value: import_zod61.z.unknown().optional() });
 var reviewFields = (raw) => {
-  const fields4 = import_zod60.z.array(import_zod60.z.unknown()).parse(raw).flatMap((field) => {
+  const fields4 = import_zod61.z.array(import_zod61.z.unknown()).parse(raw).flatMap((field) => {
     const parsed = Field.safeParse(field);
     return parsed.success ? [parsed.data] : [];
   });
@@ -6688,7 +6726,7 @@ var readJudgeMeReviews = (find) => {
   const field = find("judgeme", "badge");
   if (!field) return null;
   return readReviewField(field, (value) => {
-    const html = import_zod61.z.string().parse(value);
+    const html = import_zod62.z.string().parse(value);
     const rating = html.match(/data-average-rating=['"](\d+(?:\.\d+)?)['"]/);
     const count = html.match(/data-number-of-reviews=['"](\d+)['"]/);
     if (!rating || !count) throw new Error("Unreadable Judge.me attributes");
@@ -6700,20 +6738,20 @@ var readJudgeMeReviews = (find) => {
 };
 
 // src/server/postPurchaseOkendoReviews.ts
-var import_zod62 = require("zod");
-var Summary = import_zod62.z.object({
+var import_zod63 = require("zod");
+var Summary = import_zod63.z.object({
   reviewAverageValue: PostPurchaseCommonReviewRating.shape.value,
-  reviewCount: import_zod62.z.union([PostPurchaseProductReviews.shape.reviewCount, PostPurchaseReviewCount])
+  reviewCount: import_zod63.z.union([PostPurchaseProductReviews.shape.reviewCount, PostPurchaseReviewCount])
 });
 var readOkendoReviews = (find) => {
   const field = find("okendo", "summaryData");
   if (!field) return null;
-  const summary = readReviewField(field, (value) => Summary.parse(JSON.parse(import_zod62.z.string().parse(value))));
+  const summary = readReviewField(field, (value) => Summary.parse(JSON.parse(import_zod63.z.string().parse(value))));
   return { rating: summary.reviewAverageValue, reviewCount: summary.reviewCount };
 };
 
 // src/server/postPurchaseScalarReviews.ts
-var import_zod63 = require("zod");
+var import_zod64 = require("zod");
 var readScalarReviews = (find, namespace, ratingKey, countKey) => {
   const rating = find(namespace, ratingKey);
   const count = find(namespace, countKey);
@@ -6721,7 +6759,7 @@ var readScalarReviews = (find, namespace, ratingKey, countKey) => {
   return {
     rating: readReviewField(
       rating,
-      (value) => PostPurchaseCommonReviewRating.parse({ value: import_zod63.z.string().parse(value) }).value
+      (value) => PostPurchaseCommonReviewRating.parse({ value: import_zod64.z.string().parse(value) }).value
     ),
     reviewCount: readReviewField(count, (value) => PostPurchaseReviewCount.parse(value))
   };
@@ -6734,7 +6772,7 @@ var readStandardReviews = (find) => {
   if (!rating || !count) return null;
   return {
     rating: readReviewField(rating, (raw) => {
-      const value = import_zod64.z.string().parse(raw);
+      const value = import_zod65.z.string().parse(raw);
       return PostPurchaseCommonReviewRating.parse(/^\d+(?:\.\d+)?$/.test(value) ? { value } : JSON.parse(value)).value;
     }),
     reviewCount: readReviewField(count, (value) => PostPurchaseReviewCount.parse(value))
@@ -6756,15 +6794,15 @@ var readPostPurchaseReviewData = (provider, find) => {
   return {
     rating: readReviewField(
       rating,
-      (value) => PostPurchaseKlaviyoReviewRating.parse(JSON.parse(import_zod64.z.string().parse(value))).value
+      (value) => PostPurchaseKlaviyoReviewRating.parse(JSON.parse(import_zod65.z.string().parse(value))).value
     ),
     reviewCount: readReviewField(count, (value) => PostPurchaseReviewCount.parse(value))
   };
 };
 
 // src/server/postPurchaseReviewProvider.ts
-var import_zod65 = require("zod");
-var IntegrationInput = import_zod65.z.record(import_zod65.z.string(), import_zod65.z.unknown()).prefault({});
+var import_zod66 = require("zod");
+var IntegrationInput = import_zod66.z.record(import_zod66.z.string(), import_zod66.z.unknown()).prefault({});
 var precedence = [
   "klaviyo",
   "judgeme",
@@ -6776,7 +6814,7 @@ var precedence = [
   "stamped",
   "yotpo"
 ];
-var ReviewsIoFlag = import_zod65.z.preprocess((value) => {
+var ReviewsIoFlag = import_zod66.z.preprocess((value) => {
   if (typeof value === "string") {
     const flag = value.toLowerCase();
     if (flag === "true" || flag === "yes") return true;
@@ -6877,7 +6915,7 @@ var prepareNormalizedSubscription = (normalized, report, plan, quantity3, allowC
 
 // src/server/preparePostPurchaseSubscription.ts
 var preparePostPurchaseSubscription = (settings, response, report) => {
-  const normalized = normalizePostPurchaseProduct(settings, response);
+  const normalized = normalizePostPurchaseProduct(settings, response, report);
   return prepareNormalizedSubscription(
     normalized,
     report,
@@ -6915,42 +6953,42 @@ var prepareNormalizedProduct = (normalized, report, quantity3, allowCollection =
     }
   });
 };
-var preparePostPurchaseProduct = (settings, response, report) => prepareNormalizedProduct(normalizePostPurchaseProduct(settings, response), report);
+var preparePostPurchaseProduct = (settings, response, report) => prepareNormalizedProduct(normalizePostPurchaseProduct(settings, response, report), report);
 
 // src/schema/postPurchaseProductView.ts
-var import_zod72 = require("zod");
+var import_zod73 = require("zod");
 
 // src/schema/postPurchaseChoice.ts
-var import_zod66 = require("zod");
-var PostPurchaseChoice = import_zod66.z.discriminatedUnion("mode", [
-  import_zod66.z.object({ mode: import_zod66.z.literal("one-time") }).strict(),
-  import_zod66.z.object({ mode: import_zod66.z.literal("subscription"), sellingPlanId: PostPurchasePlanOption.shape.id }).strict()
+var import_zod67 = require("zod");
+var PostPurchaseChoice = import_zod67.z.discriminatedUnion("mode", [
+  import_zod67.z.object({ mode: import_zod67.z.literal("one-time") }).strict(),
+  import_zod67.z.object({ mode: import_zod67.z.literal("subscription"), sellingPlanId: PostPurchasePlanOption.shape.id }).strict()
 ]);
-var PostPurchaseOptions = import_zod66.z.object({
+var PostPurchaseOptions = import_zod67.z.object({
   defaultChoice: PostPurchaseChoice,
-  modes: import_zod66.z.array(import_zod66.z.enum(["one-time", "subscription"])).min(1).max(2),
+  modes: import_zod67.z.array(import_zod67.z.enum(["one-time", "subscription"])).min(1).max(2),
   selector: PostPurchaseSettings.shape.productTypeSelector
 });
 
 // src/schema/postPurchaseDisplayPrice.ts
-var import_zod68 = require("zod");
+var import_zod69 = require("zod");
 
 // src/schema/postPurchaseSubscriptionDisplay.ts
-var import_zod67 = require("zod");
-var Minor = import_zod67.z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
-var PostPurchaseSubscriptionDisplay = import_zod67.z.object({
+var import_zod68 = require("zod");
+var Minor = import_zod68.z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+var PostPurchaseSubscriptionDisplay = import_zod68.z.object({
   comparisonMinor: Minor,
-  currencyCode: import_zod67.z.string().regex(/^[A-Z]{3}$/),
+  currencyCode: import_zod68.z.string().regex(/^[A-Z]{3}$/),
   priceMinor: Minor,
   savingMinor: Minor,
-  savingPercent: import_zod67.z.number().int().min(0).max(100)
+  savingPercent: import_zod68.z.number().int().min(0).max(100)
 });
 
 // src/schema/postPurchaseDisplayPrice.ts
 var { currencyCode: CurrencyCode, priceMinor: Minor2, savingPercent: Percent } = PostPurchaseSubscriptionDisplay.shape;
-var PostPurchaseDisplayPrice = import_zod68.z.object({
+var PostPurchaseDisplayPrice = import_zod69.z.object({
   currencyCode: CurrencyCode,
-  savingFormat: import_zod68.z.enum(["amount", "percent"]).nullable(),
+  savingFormat: import_zod69.z.enum(["amount", "percent"]).nullable(),
   savingMinor: Minor2,
   savingPercent: Percent,
   subscriptionUnit: PostPurchaseSubscriptionDisplay.optional(),
@@ -6968,30 +7006,30 @@ var PostPurchaseDisplayPrice = import_zod68.z.object({
 );
 
 // src/schema/postPurchaseGroupCatalog.ts
-var import_zod70 = require("zod");
+var import_zod71 = require("zod");
 
 // src/schema/postPurchaseVariantCatalog.ts
-var import_zod69 = require("zod");
-var PostPurchaseVariantSelector = import_zod69.z.object({ variantId: PostPurchaseVariantId }).strict();
+var import_zod70 = require("zod");
+var PostPurchaseVariantSelector = import_zod70.z.object({ variantId: PostPurchaseVariantId }).strict();
 var PostPurchaseVariantOption = OfferProduct.shape.options.element.extend({
-  id: import_zod69.z.number().int().positive().optional(),
-  position: import_zod69.z.number().int().min(1).max(3)
+  id: import_zod70.z.number().int().positive().optional(),
+  position: import_zod70.z.number().int().min(1).max(3)
 });
 var PostPurchaseVariantValues = OfferProduct.shape.variants.element.pick({
   option1: true,
   option2: true,
   option3: true
 });
-var PostPurchaseVariantCatalog = import_zod69.z.object({
+var PostPurchaseVariantCatalog = import_zod70.z.object({
   displayMode: PostPurchaseSettings.shape.productOptions.shape.variantSelectorDisplayMode,
-  options: import_zod69.z.array(PostPurchaseVariantOption),
+  options: import_zod70.z.array(PostPurchaseVariantOption),
   productId: PostPurchaseProductId,
   showSelectors: PostPurchaseSettings.shape.productOptions.shape.showVariantSelectors,
-  variants: import_zod69.z.array(
+  variants: import_zod70.z.array(
     PostPurchaseVariantValues.partial().extend({
-      available: import_zod69.z.boolean(),
+      available: import_zod70.z.boolean(),
       id: PostPurchaseVariantId,
-      imageId: import_zod69.z.number().int().nonnegative().nullish(),
+      imageId: import_zod70.z.number().int().nonnegative().nullish(),
       title: OfferProduct.shape.variants.element.shape.title
     })
   )
@@ -7005,89 +7043,89 @@ var PostPurchaseGroupDescription = source.pick({ description: true, id: true, im
   image: source.shape.image.default(null),
   options: PostPurchaseVariantCatalog.shape.options.default([])
 });
-var PostPurchaseGroupCatalog = import_zod70.z.object({
+var PostPurchaseGroupCatalog = import_zod71.z.object({
   memberProductId: productId,
-  options: import_zod70.z.array(import_zod70.z.object({ productId, title: import_zod70.z.string(), variantCatalog: PostPurchaseVariantCatalog }))
+  options: import_zod71.z.array(import_zod71.z.object({ productId, title: import_zod71.z.string(), variantCatalog: PostPurchaseVariantCatalog }))
 });
-var PostPurchaseGroupSelection = import_zod70.z.object({
+var PostPurchaseGroupSelection = import_zod71.z.object({
   memberProductId: productId,
   productId
 });
 
 // src/schema/postPurchaseProductCalculation.ts
-var import_zod71 = require("zod");
-var MoneyBag = import_zod71.z.object({
-  presentmentMoney: import_zod71.z.object({
+var import_zod72 = require("zod");
+var MoneyBag = import_zod72.z.object({
+  presentmentMoney: import_zod72.z.object({
     amount: PostPurchaseAmount,
-    currencyCode: import_zod71.z.string().regex(/^[A-Z]{3}$/)
+    currencyCode: import_zod72.z.string().regex(/^[A-Z]{3}$/)
   })
 });
-var PostPurchaseProductCalculation = import_zod71.z.object({
-  calculatedPurchase: import_zod71.z.object({
-    addedShippingLines: import_zod71.z.array(import_zod71.z.object({ priceSet: MoneyBag })),
-    addedTaxLines: import_zod71.z.array(import_zod71.z.object({ priceSet: MoneyBag })),
+var PostPurchaseProductCalculation = import_zod72.z.object({
+  calculatedPurchase: import_zod72.z.object({
+    addedShippingLines: import_zod72.z.array(import_zod72.z.object({ priceSet: MoneyBag })),
+    addedTaxLines: import_zod72.z.array(import_zod72.z.object({ priceSet: MoneyBag })),
     totalOutstandingSet: MoneyBag,
-    updatedLineItems: import_zod71.z.array(
-      import_zod71.z.object({
-        priceSet: import_zod71.z.unknown().optional(),
-        productId: import_zod71.z.number().int().positive(),
-        sellingPlanId: import_zod71.z.unknown().optional(),
-        variantId: import_zod71.z.number().int().positive()
+    updatedLineItems: import_zod72.z.array(
+      import_zod72.z.object({
+        priceSet: import_zod72.z.unknown().optional(),
+        productId: import_zod72.z.number().int().positive(),
+        sellingPlanId: import_zod72.z.unknown().optional(),
+        variantId: import_zod72.z.number().int().positive()
       })
     )
   }),
-  errors: import_zod71.z.array(import_zod71.z.unknown()).length(0),
-  status: import_zod71.z.literal("processed")
+  errors: import_zod72.z.array(import_zod72.z.unknown()).length(0),
+  status: import_zod72.z.literal("processed")
 });
-var Minor3 = import_zod71.z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
-var PostPurchaseProductCosts = import_zod71.z.object({
+var Minor3 = import_zod72.z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+var PostPurchaseProductCosts = import_zod72.z.object({
   currencyCode: MoneyBag.shape.presentmentMoney.shape.currencyCode,
-  recurringDisplay: import_zod71.z.object({ shippingMinor: Minor3, subtotalMinor: Minor3, totalMinor: Minor3 }).optional(),
+  recurringDisplay: import_zod72.z.object({ shippingMinor: Minor3, subtotalMinor: Minor3, totalMinor: Minor3 }).optional(),
   shippingMinor: Minor3,
   subtotalMinor: Minor3,
   taxesMinor: Minor3,
   totalMinor: Minor3
 });
-var ChangesetDiscount = import_zod71.z.object({
-  title: import_zod71.z.string(),
-  value: import_zod71.z.number().nonnegative(),
-  valueType: import_zod71.z.enum(["percentage", "fixed_amount"])
+var ChangesetDiscount = import_zod72.z.object({
+  title: import_zod72.z.string(),
+  value: import_zod72.z.number().nonnegative(),
+  valueType: import_zod72.z.enum(["percentage", "fixed_amount"])
 }).optional();
-var PostPurchaseProductChangeset = import_zod71.z.object({
-  changes: import_zod71.z.array(
-    import_zod71.z.union([
-      import_zod71.z.object({
+var PostPurchaseProductChangeset = import_zod72.z.object({
+  changes: import_zod72.z.array(
+    import_zod72.z.union([
+      import_zod72.z.object({
         discount: ChangesetDiscount,
-        quantity: import_zod71.z.number().int().positive(),
-        type: import_zod71.z.literal("add_variant"),
-        variantId: import_zod71.z.number().int().positive()
+        quantity: import_zod72.z.number().int().positive(),
+        type: import_zod72.z.literal("add_variant"),
+        variantId: import_zod72.z.number().int().positive()
       }),
-      import_zod71.z.object({ price: import_zod71.z.number().nonnegative(), title: import_zod71.z.string(), type: import_zod71.z.literal("add_shipping_line") }),
+      import_zod72.z.object({ price: import_zod72.z.number().nonnegative(), title: import_zod72.z.string(), type: import_zod72.z.literal("add_shipping_line") }),
       PostPurchaseSubscriptionTerms.pick({
         initialShippingPrice: true,
         recurringShippingPrice: true,
         shippingOption: true
       }).extend({
         discount: ChangesetDiscount,
-        quantity: import_zod71.z.number().int().positive(),
-        sellingPlanId: import_zod71.z.number().int().positive(),
-        type: import_zod71.z.literal("add_subscription"),
-        variantId: import_zod71.z.number().int().positive()
+        quantity: import_zod72.z.number().int().positive(),
+        sellingPlanId: import_zod72.z.number().int().positive(),
+        type: import_zod72.z.literal("add_subscription"),
+        variantId: import_zod72.z.number().int().positive()
       })
     ])
   )
 });
 
 // src/schema/postPurchaseProductView.ts
-var PostPurchaseProductView = import_zod72.z.union([
-  import_zod72.z.object({
+var PostPurchaseProductView = import_zod73.z.union([
+  import_zod73.z.object({
     changeset: PostPurchaseProductChangeset.optional(),
     displayPrice: PostPurchaseDisplayPrice.optional(),
     groupCatalog: PostPurchaseGroupCatalog.optional(),
     initialVariant: PostPurchaseVariantSelector.optional(),
     planCatalog: PostPurchasePlanCatalog.nullable().optional(),
     preparation: PreparedPostPurchaseProduct.extend({
-      display: PreparedPostPurchaseProduct.shape.display.extend({ description: import_zod72.z.string().nullable() }).refine(
+      display: PreparedPostPurchaseProduct.shape.display.extend({ description: import_zod73.z.string().nullable() }).refine(
         ({ description, descriptionDocument }) => description === null === (descriptionDocument !== void 0),
         "Exactly one of the plain and rich descriptions is shown"
       )
@@ -7096,7 +7134,7 @@ var PostPurchaseProductView = import_zod72.z.union([
     sections: CABRootSection,
     variantCatalog: PostPurchaseVariantCatalog.optional()
   }),
-  import_zod72.z.object({
+  import_zod73.z.object({
     groupCatalog: PostPurchaseGroupCatalog.optional(),
     initialVariant: PostPurchaseVariantSelector.optional(),
     /** The localized unavailable copy, for the choices still offered beneath an unprepared product. */
@@ -7111,12 +7149,12 @@ var PostPurchaseProductView = import_zod72.z.union([
 ]);
 
 // src/server/postPurchaseOfferCopy.ts
-var import_zod73 = require("zod");
-var Copy = import_zod73.z.object({
+var import_zod74 = require("zod");
+var Copy = import_zod74.z.object({
   superTitle: CalloutBannerBlock.shape.settings.shape.superTitle.unwrap().optional().catch(void 0),
   title: CalloutBannerBlock.shape.settings.shape.title.unwrap().optional().catch(void 0)
 });
-var Callout = import_zod73.z.object({ settings: import_zod73.z.record(import_zod73.z.string(), import_zod73.z.unknown()), type: import_zod73.z.literal("callout_banner") });
+var Callout = import_zod74.z.object({ settings: import_zod74.z.record(import_zod74.z.string(), import_zod74.z.unknown()), type: import_zod74.z.literal("callout_banner") });
 var postPurchaseOfferCopy = (blocks, metadata) => {
   const copy = Copy.safeParse(metadata.widget.language);
   if (!blocks || !copy.success) return blocks;
@@ -7150,7 +7188,7 @@ var postPurchaseCardSections = (widgetId, { effective, metadata }, report) => {
   );
   return sections.sections.filter(({ sectionType }) => sectionType === "offers").length === 1 ? sections : null;
 };
-var preparePostPurchaseCardSections = (widgetId, settings, response, report) => postPurchaseCardSections(widgetId, normalizePostPurchaseProduct(settings, response), report);
+var preparePostPurchaseCardSections = (widgetId, settings, response, report) => postPurchaseCardSections(widgetId, normalizePostPurchaseProduct(settings, response, report), report);
 
 // src/server/selectPostPurchaseChoice.ts
 var preferChoiceLevel = (preferred, other) => !isChoiceUnavailable(preferred) && isChoiceUnavailable(other) ? other : preferred;
@@ -7220,72 +7258,77 @@ var prepareNormalizedPostPurchaseView = (widgetId, normalized, report, choice, q
     sections
   });
 };
-var preparePostPurchaseView = (widgetId, settings, response, report, choice) => prepareNormalizedPostPurchaseView(widgetId, normalizePostPurchaseProduct(settings, response), report, choice);
+var preparePostPurchaseView = (widgetId, settings, response, report, choice) => prepareNormalizedPostPurchaseView(
+  widgetId,
+  normalizePostPurchaseProduct(settings, response, report),
+  report,
+  choice
+);
 
 // src/server/preparePostPurchaseAdmissionView.ts
 var preparePostPurchaseAdmissionView = (widgetId, settings, response, report, choice) => {
-  const normalized = normalizePostPurchaseProduct(settings, response);
+  const normalized = normalizePostPurchaseProduct(settings, response, report);
   const view = prepareNormalizedPostPurchaseView(widgetId, normalized, report, choice);
   const { removePartialOrder } = PostPurchaseSettings.shape.advance.parse(normalized.effective.advance);
   return { removePartialOrder, view };
 };
 
 // src/schema/postPurchaseProductCollectionView.ts
-var import_zod80 = require("zod");
+var import_zod81 = require("zod");
 
 // src/schema/postPurchaseProgress.ts
-var import_zod79 = require("zod");
+var import_zod80 = require("zod");
 
 // src/schema/postPurchaseDeclineDelivery.ts
-var import_zod78 = require("zod");
+var import_zod79 = require("zod");
 
 // src/schema/postPurchaseAcceptedEvent.ts
-var import_zod77 = require("zod");
+var import_zod78 = require("zod");
 
 // src/schema/postPurchaseAdmission.ts
-var import_zod76 = require("zod");
+var import_zod77 = require("zod");
 
 // src/schema/postPurchaseIdentity.ts
-var import_zod74 = require("zod");
+var import_zod75 = require("zod");
 var POST_PURCHASE_ID_MAX = 128;
-var PostPurchaseTimestampSchema = import_zod74.z.number().int().nonnegative();
-var PostPurchaseOrderIdSchema = import_zod74.z.string().regex(/^gid:\/\/shopify\/Order\/[1-9]\d*$/);
-var ShopifyDomainSchema = import_zod74.z.string().max(POST_PURCHASE_ID_MAX).regex(/^[a-z0-9]([a-z0-9-]*[a-z0-9])?\.myshopify\.com$/);
-var DecideRequestSchema = import_zod74.z.object({
-  checkoutToken: import_zod74.z.string().min(1).max(POST_PURCHASE_ID_MAX),
+var PostPurchaseTimestampSchema = import_zod75.z.number().int().nonnegative();
+var PostPurchaseOrderIdSchema = import_zod75.z.string().regex(/^gid:\/\/shopify\/Order\/[1-9]\d*$/);
+var ShopifyDomainSchema = import_zod75.z.string().max(POST_PURCHASE_ID_MAX).regex(/^[a-z0-9]([a-z0-9-]*[a-z0-9])?\.myshopify\.com$/);
+var DecideRequestSchema = import_zod75.z.object({
+  checkoutToken: import_zod75.z.string().min(1).max(POST_PURCHASE_ID_MAX),
   shop: ShopifyDomainSchema
 });
-var PostPurchaseAppIdSchema = import_zod74.z.string().min(1).max(POST_PURCHASE_ID_MAX);
-var DecisionEntrySchema = import_zod74.z.object({
-  blockId: import_zod74.z.number().int().positive(),
-  blockIndex: import_zod74.z.string(),
-  blockParentIndex: import_zod74.z.string(),
-  flowId: import_zod74.z.number().int().positive(),
-  sectionId: import_zod74.z.number().int().positive(),
-  widgetId: import_zod74.z.number().int().positive(),
-  widgetTraffic: import_zod74.z.number().min(0).max(100)
+var PostPurchaseAppIdSchema = import_zod75.z.string().min(1).max(POST_PURCHASE_ID_MAX);
+var DecisionEntrySchema = import_zod75.z.object({
+  blockId: import_zod75.z.number().int().positive(),
+  blockIndex: import_zod75.z.string(),
+  blockParentIndex: import_zod75.z.string(),
+  flowId: import_zod75.z.number().int().positive(),
+  sectionId: import_zod75.z.number().int().positive(),
+  widgetId: import_zod75.z.number().int().positive(),
+  widgetTraffic: import_zod75.z.number().min(0).max(100)
 });
 
 // src/schema/postPurchaseMemberIdentity.ts
-var import_zod75 = require("zod");
-var PostPurchaseMemberIdentity = import_zod75.z.object({
-  productId: import_zod75.z.number().int().positive(),
-  productIndex: import_zod75.z.number().int().nonnegative()
+var import_zod76 = require("zod");
+var PostPurchaseMemberIdentity = import_zod76.z.object({
+  productId: import_zod76.z.number().int().positive(),
+  productIndex: import_zod76.z.number().int().nonnegative()
 }).strict();
 
 // src/schema/postPurchaseAdmission.ts
-var PurchaseAdmissionModeSchema = import_zod76.z.enum(["purchase", "sts"]);
+var PurchaseAdmissionModeSchema = import_zod77.z.enum(["purchase", "sts"]);
 var selection = PreparedPostPurchaseProduct.shape.selection;
 var EventCalculationSchema = PostPurchaseProductCosts.pick({ currencyCode: true, totalMinor: true }).strict();
-var PurchaseExpectedSchema = import_zod76.z.object({
-  buyerConsentToSubscriptions: import_zod76.z.boolean().optional(),
+var PurchaseExpectedSchema = import_zod77.z.object({
+  buyerConsentToSubscriptions: import_zod77.z.boolean().optional(),
   changeset: PostPurchaseProductChangeset.extend({
     changes: PostPurchaseProductChangeset.shape.changes.min(1).max(2)
   }),
   entry: DecisionEntrySchema,
   member: PostPurchaseMemberIdentity.optional(),
   mode: PurchaseAdmissionModeSchema.optional(),
-  progressRevision: import_zod76.z.number().int().nonnegative().optional(),
+  progressRevision: import_zod77.z.number().int().nonnegative().optional(),
   /**
    * The total the buyer affirmed, stored with the admitted operation so a reloaded client can still
    * send its follow-ups with it. Optional: a client from before it was added admits without one.
@@ -7306,16 +7349,16 @@ var PurchaseExpectedSchema = import_zod76.z.object({
 }, "Selection, change and buyer consent must agree");
 var PurchaseRequestSchema = DecideRequestSchema.extend({
   expected: PurchaseExpectedSchema,
-  requestId: import_zod76.z.uuid()
+  requestId: import_zod77.z.uuid()
 }).strict();
-var PurchaseReceiptSchema = import_zod76.z.object({
+var PurchaseReceiptSchema = import_zod77.z.object({
   admittedAt: PostPurchaseTimestampSchema,
-  changesetToken: import_zod76.z.string().min(1),
+  changesetToken: import_zod77.z.string().min(1),
   mode: PurchaseAdmissionModeSchema.optional(),
-  operationId: import_zod76.z.uuid(),
+  operationId: import_zod77.z.uuid(),
   /** The server-bound one-time line an STS refunds; its quantity is the order's, not the selection's. */
-  originalLine: import_zod76.z.strictObject({ quantity: selection.shape.quantity, variantId: selection.shape.variantId }).optional(),
-  requiresSubscriptionConsent: import_zod76.z.boolean(),
+  originalLine: import_zod77.z.strictObject({ quantity: selection.shape.quantity, variantId: selection.shape.variantId }).optional(),
+  requiresSubscriptionConsent: import_zod77.z.boolean(),
   selection
 }).refine(
   ({ requiresSubscriptionConsent, selection: selection4 }) => requiresSubscriptionConsent === (selection4.sellingPlanId !== void 0),
@@ -7324,14 +7367,14 @@ var PurchaseReceiptSchema = import_zod76.z.object({
   ({ mode, originalLine, selection: { sellingPlanId, variantId } }) => mode === "sts" ? sellingPlanId !== void 0 && originalLine?.variantId === variantId : originalLine === void 0,
   "An STS Receipt binds the original line of its subscribed variant, and only an STS does"
 );
-var PurchaseResponseSchema = import_zod76.z.object({ data: PurchaseReceiptSchema, successful: import_zod76.z.literal(true) });
+var PurchaseResponseSchema = import_zod77.z.object({ data: PurchaseReceiptSchema, successful: import_zod77.z.literal(true) });
 
 // src/schema/postPurchaseAcceptedEvent.ts
-var AcceptedEventOutcomeSchema = import_zod77.z.enum(["acknowledged", "rejected", "skipped", "unknown"]);
-var AttemptProgressSchema = import_zod77.z.strictObject({
+var AcceptedEventOutcomeSchema = import_zod78.z.enum(["acknowledged", "rejected", "skipped", "unknown"]);
+var AttemptProgressSchema = import_zod78.z.strictObject({
   attemptedAt: PostPurchaseTimestampSchema,
   reportedCalculation: EventCalculationSchema,
-  status: import_zod77.z.literal("attempted")
+  status: import_zod78.z.literal("attempted")
 });
 var AcceptedEventAttemptProgressSchema = AttemptProgressSchema.extend({
   operationId: PurchaseReceiptSchema.shape.operationId
@@ -7344,17 +7387,17 @@ var AcceptedEventRequestSchema = DecideRequestSchema.extend({
   operationId: PurchaseReceiptSchema.shape.operationId,
   reportedCalculation: EventCalculationSchema
 }).strict();
-var AcceptedEventResponseSchema = import_zod77.z.object({
-  data: import_zod77.z.union([AcceptedEventAttemptProgressSchema, AcceptedEventResultProgressSchema]),
-  successful: import_zod77.z.literal(true)
+var AcceptedEventResponseSchema = import_zod78.z.object({
+  data: import_zod78.z.union([AcceptedEventAttemptProgressSchema, AcceptedEventResultProgressSchema]),
+  successful: import_zod78.z.literal(true)
 });
 
 // src/schema/postPurchaseDeclineDelivery.ts
-var AttemptSchema = import_zod78.z.strictObject({
+var AttemptSchema = import_zod79.z.strictObject({
   attemptedAt: PostPurchaseTimestampSchema,
-  status: import_zod78.z.enum(["attempted", "unavailable"])
+  status: import_zod79.z.enum(["attempted", "unavailable"])
 });
-var DeclineDeliveryProgressSchema = import_zod78.z.union([
+var DeclineDeliveryProgressSchema = import_zod79.z.union([
   AttemptSchema,
   AttemptSchema.extend({
     finishedAt: PostPurchaseTimestampSchema,
@@ -7363,36 +7406,36 @@ var DeclineDeliveryProgressSchema = import_zod78.z.union([
 ]);
 
 // src/schema/postPurchaseProgress.ts
-var PostPurchaseProgressSchema = import_zod79.z.object({
+var PostPurchaseProgressSchema = import_zod80.z.object({
   closedAt: PostPurchaseTimestampSchema.nullable(),
   deadline: PostPurchaseTimestampSchema,
   entry: DecisionEntrySchema,
-  entryRevision: import_zod79.z.number().int().nonnegative(),
-  members: import_zod79.z.array(
+  entryRevision: import_zod80.z.number().int().nonnegative(),
+  members: import_zod80.z.array(
     PostPurchaseMemberIdentity.extend({
       declineDelivery: DeclineDeliveryProgressSchema.optional(),
-      status: import_zod79.z.enum(["unhandled", "accepted", "declined"])
+      status: import_zod80.z.enum(["unhandled", "accepted", "declined"])
     }).strict()
   ),
-  revision: import_zod79.z.number().int().nonnegative()
+  revision: import_zod80.z.number().int().nonnegative()
 }).strict();
 
 // src/schema/postPurchaseProductCollectionView.ts
-var PostPurchaseProductCollectionView = import_zod80.z.object({
-  members: import_zod80.z.array(
-    import_zod80.z.object({
+var PostPurchaseProductCollectionView = import_zod81.z.object({
+  members: import_zod81.z.array(
+    import_zod81.z.object({
       productId: PostPurchaseProductId,
-      productIndex: import_zod80.z.number().int().nonnegative(),
+      productIndex: import_zod81.z.number().int().nonnegative(),
       view: PostPurchaseProductView
     })
   )
 });
-var PostPurchaseCollectionChoice = import_zod80.z.object({
+var PostPurchaseCollectionChoice = import_zod81.z.object({
   choice: PostPurchaseChoice.optional(),
   productId: PostPurchaseProductId,
   variantId: PostPurchaseVariantSelector.shape.variantId.optional()
 }).strict();
-var PostPurchaseExcludedProductIds = import_zod80.z.array(PostPurchaseProductId).default([]);
+var PostPurchaseExcludedProductIds = import_zod81.z.array(PostPurchaseProductId).default([]);
 var PostPurchaseMemberSelector = PostPurchaseProgressSchema.shape.members.element.pick({ productId: true }).extend({ progressRevision: PostPurchaseProgressSchema.shape.revision });
 var PostPurchaseMemberPointer = PostPurchaseProgressSchema.shape.members.element.omit({ status: true }).extend({
   entryRevision: PostPurchaseProgressSchema.shape.entryRevision,
@@ -7400,16 +7443,19 @@ var PostPurchaseMemberPointer = PostPurchaseProgressSchema.shape.members.element
 });
 
 // src/server/normalizePostPurchaseCollection.ts
-var import_zod81 = require("zod");
-var normalizePostPurchaseCollection = (settings, response, excludedProductIds) => {
-  const normalized = normalizePostPurchaseProduct(settings, response);
-  const limit = import_zod81.z.number().int().positive();
+var import_zod82 = require("zod");
+var normalizePostPurchaseCollection = (settings, response, excludedProductIds, report) => {
+  const { dropped, normalized, products } = normalizePostPurchaseSource(settings, response, report);
+  const limit = import_zod82.z.number().int().positive();
   limit.parse(normalized.original.productLimit);
-  const prefix = normalized.data.slice(0, limit.parse(normalized.effective.productLimit));
-  if (new Set(prefix.map(({ id }) => id)).size !== prefix.length)
+  const cap = limit.parse(normalized.effective.productLimit);
+  const prefix = products.filter(({ productIndex }) => productIndex < cap);
+  const unread = dropped.filter(({ productIndex }) => productIndex < cap);
+  if (unread.length && !prefix.length) throw new import_zod82.ZodError(unread.flatMap(({ issues }) => issues));
+  if (new Set(prefix.map(({ product }) => product.id)).size !== prefix.length)
     throw new Error("Ambiguous post-purchase collection");
   const excluded = new Set(PostPurchaseExcludedProductIds.parse(excludedProductIds));
-  const members = prefix.map((product, productIndex) => ({ product, productIndex })).filter(({ product }) => !excluded.has(product.id));
+  const members = prefix.filter(({ product }) => !excluded.has(product.id));
   return { members, normalized };
 };
 
@@ -7447,40 +7493,40 @@ var projectPostPurchaseVariantCatalog = (product, settings) => {
 };
 
 // src/schema/postPurchaseOfferEligibility.ts
-var import_zod82 = require("zod");
+var import_zod83 = require("zod");
 var selection2 = PreparedPostPurchaseProduct.shape.selection;
-var PostPurchaseOfferSkipReason = import_zod82.z.enum(["empty", "no-eligible-subscription"]);
-var PostPurchaseOfferEligibilityContext = import_zod82.z.object({
+var PostPurchaseOfferSkipReason = import_zod83.z.enum(["empty", "no-eligible-subscription"]);
+var PostPurchaseOfferEligibilityContext = import_zod83.z.object({
   excludedProductIds: PostPurchaseExcludedProductIds,
-  originalLineItems: import_zod82.z.array(selection2.pick({ productId: true, sellingPlanId: true, variantId: true }))
+  originalLineItems: import_zod83.z.array(selection2.pick({ productId: true, sellingPlanId: true, variantId: true }))
 });
-var PostPurchaseStsOptions = import_zod82.z.object({ sts: import_zod82.z.boolean().optional() }).strict();
-var PostPurchaseStsContext = import_zod82.z.object({
-  originalLineItems: import_zod82.z.array(
+var PostPurchaseStsOptions = import_zod83.z.object({ sts: import_zod83.z.boolean().optional() }).strict();
+var PostPurchaseStsContext = import_zod83.z.object({
+  originalLineItems: import_zod83.z.array(
     selection2.pick({ productId: true, quantity: true, sellingPlanId: true, variantId: true })
   )
 });
-var PostPurchaseOfferEligibility = import_zod82.z.discriminatedUnion("status", [
-  import_zod82.z.object({
-    members: import_zod82.z.array(
-      import_zod82.z.object({ productId: selection2.shape.productId, productIndex: import_zod82.z.number().int().nonnegative() })
+var PostPurchaseOfferEligibility = import_zod83.z.discriminatedUnion("status", [
+  import_zod83.z.object({
+    members: import_zod83.z.array(
+      import_zod83.z.object({ productId: selection2.shape.productId, productIndex: import_zod83.z.number().int().nonnegative() })
     ),
     /** Present only with STS on: each member switches one original one-time line to subscription. */
-    mode: import_zod82.z.literal("sts").optional(),
-    status: import_zod82.z.literal("retain")
+    mode: import_zod83.z.literal("sts").optional(),
+    status: import_zod83.z.literal("retain")
   }),
-  import_zod82.z.object({ reason: PostPurchaseOfferSkipReason, status: import_zod82.z.literal("skip") }),
-  import_zod82.z.object({ reason: import_zod82.z.literal("eligible-sts").optional(), status: import_zod82.z.literal("unavailable") })
+  import_zod83.z.object({ reason: PostPurchaseOfferSkipReason, status: import_zod83.z.literal("skip") }),
+  import_zod83.z.object({ reason: import_zod83.z.literal("eligible-sts").optional(), status: import_zod83.z.literal("unavailable") })
 ]);
 
 // src/schema/postPurchaseQuantity.ts
-var import_zod83 = require("zod");
+var import_zod84 = require("zod");
 var quantity2 = PreparedPostPurchaseProduct.shape.selection.shape.quantity;
 var PostPurchaseQuantityChoice = PostPurchaseCollectionChoice.extend({ quantity: quantity2.optional() });
 var PostPurchaseQuantityPolicy = PostPurchaseSettings.shape.quantityInputs.omit({ defaultQuantity: true }).extend({
   initialQuantity: quantity2,
   maxValue: quantity2,
-  minValue: import_zod83.z.literal(0).transform(() => 1).or(quantity2)
+  minValue: import_zod84.z.literal(0).transform(() => 1).or(quantity2)
 }).refine(({ maxValue, minValue }) => minValue <= maxValue, "Quantity bounds are reversed");
 
 // src/server/readPostPurchaseQuantity.ts
@@ -7548,7 +7594,7 @@ var prepareStsCollectionMember = (widgetId, normalized, { product, productIndex
 
 // src/server/preparePostPurchaseStsMember.ts
 var preparePostPurchaseStsMember = (widgetId, settings, response, selected, sts, requestedQuantity, report) => {
-  const { members, normalized } = normalizePostPurchaseCollection(settings, response);
+  const { members, normalized } = normalizePostPurchaseCollection(settings, response, void 0, report);
   if (!stsAllowed(normalized)) return void 0;
   const member = members.find(({ product }) => product.id === selected.productId);
   const quantity3 = requestedQuantity && ("quantity" in requestedQuantity ? requestedQuantity.quantity : requestedQuantity.expectedQuantity);
@@ -7559,39 +7605,39 @@ var preparePostPurchaseStsMember = (widgetId, settings, response, selected, sts,
 };
 
 // src/schema/postPurchaseVariantDefault.ts
-var import_zod84 = require("zod");
+var import_zod85 = require("zod");
 var values = PostPurchaseVariantValues.partial().extend({
   option1: PostPurchaseVariantValues.shape.option1.nullish()
 });
 var variant = values.extend({
   id: PostPurchaseVariantId,
-  inventoryManagement: import_zod84.z.string().nullable(),
-  inventoryPolicy: import_zod84.z.string(),
-  inventoryQuantity: import_zod84.z.number()
+  inventoryManagement: import_zod85.z.string().nullable(),
+  inventoryPolicy: import_zod85.z.string(),
+  inventoryQuantity: import_zod85.z.number()
 });
-var options = import_zod84.z.array(PostPurchaseVariantOption.pick({ name: true, values: true }));
-var PostPurchaseVariantDefaultProduct = import_zod84.z.object({
+var options = import_zod85.z.array(PostPurchaseVariantOption.pick({ name: true, values: true }));
+var PostPurchaseVariantDefaultProduct = import_zod85.z.object({
   id: PostPurchaseProductId,
   options,
   selectedVariant: variant.optional(),
-  variants: import_zod84.z.array(variant)
+  variants: import_zod85.z.array(variant)
 });
 var PostPurchaseVariantDefaultSettings = PostPurchaseSettings.shape.productOptions.pick({
   hideOutOfStockVariants: true,
   matchVariant: true
 });
-var PostPurchaseOrderAttributes = import_zod84.z.record(import_zod84.z.string(), import_zod84.z.array(import_zod84.z.string())).default({});
-var PostPurchaseOriginalVariants = import_zod84.z.array(
-  import_zod84.z.object({ productId: PostPurchaseProductId, variantId: PostPurchaseVariantId })
+var PostPurchaseOrderAttributes = import_zod85.z.record(import_zod85.z.string(), import_zod85.z.array(import_zod85.z.string())).default({});
+var PostPurchaseOriginalVariants = import_zod85.z.array(
+  import_zod85.z.object({ productId: PostPurchaseProductId, variantId: PostPurchaseVariantId })
 );
-var PostPurchaseAttributeProducts = import_zod84.z.array(
-  import_zod84.z.object({ id: PostPurchaseProductId, options, variants: import_zod84.z.array(values.extend({ id: PostPurchaseVariantId })) })
+var PostPurchaseAttributeProducts = import_zod85.z.array(
+  import_zod85.z.object({ id: PostPurchaseProductId, options, variants: import_zod85.z.array(values.extend({ id: PostPurchaseVariantId })) })
 );
 
 // src/schema/postPurchaseVariantDefaultContext.ts
-var import_zod85 = require("zod");
-var PostPurchaseVariantDefaultContext = import_zod85.z.object({
-  enrichedLineItems: import_zod85.z.unknown().optional(),
+var import_zod86 = require("zod");
+var PostPurchaseVariantDefaultContext = import_zod86.z.object({
+  enrichedLineItems: import_zod86.z.unknown().optional(),
   originalVariants: PostPurchaseOriginalVariants
 });
 
@@ -7670,7 +7716,7 @@ var prepareMember = (widgetId, settings, response, requested, report, excludedPr
   const selected = PostPurchaseCollectionChoice.parse(requested);
   const stsResult = sts && preparePostPurchaseStsMember(widgetId, settings, response, selected, sts, requestedQuantity, report);
   if (stsResult !== void 0) return stsResult;
-  const { members, normalized } = normalizePostPurchaseCollection(settings, response, excludedProductIds);
+  const { members, normalized } = normalizePostPurchaseCollection(settings, response, excludedProductIds, report);
   const found = members.find(({ product: product2 }) => product2.id === selected.productId);
   if (!found) return null;
   const variantId = selected.variantId ?? (defaults && resolvePostPurchaseMemberDefault(found.product, normalized.original, defaults));
@@ -7844,7 +7890,7 @@ var preparePostPurchaseGroupAdmissionView = (widgetId, settings, response, reque
 
 // src/server/preparePostPurchaseGroupDefault.ts
 var preparePostPurchaseGroupDefault = (widgetId, settings, response, memberProductId, context, report, excludedProductIds) => {
-  const { members, normalized } = normalizePostPurchaseCollection(settings, response);
+  const { members, normalized } = normalizePostPurchaseCollection(settings, response, void 0, report);
   const member = members.find(({ product }) => product.id === memberProductId);
   if (!member || !member.product.productGroupVariants.length) return null;
   const group = readPostPurchaseGroup(member.product, normalized.effective, excludedProductIds);
@@ -7903,7 +7949,7 @@ var preparePostPurchaseCollectionGroup = (widgetId, settings, response, member,
 // src/server/preparePostPurchaseCollectionView.ts
 var CollectionChoice = PostPurchaseCollectionChoice.omit({ variantId: true });
 var preparePostPurchaseCollectionView = (widgetId, settings, response, report, requested, excludedProductIds, defaults, sts) => {
-  const { members, normalized } = normalizePostPurchaseCollection(settings, response);
+  const { members, normalized } = normalizePostPurchaseCollection(settings, response, void 0, report);
   const excluded = PostPurchaseExcludedProductIds.parse(excludedProductIds);
   const selected = CollectionChoice.optional().parse(requested);
   const stsMode = sts && stsAllowed(normalized) ? sts : void 0;
@@ -8029,10 +8075,10 @@ var classifyPostPurchaseOffer = (settings, response, context, options2) => {
 };
 
 // src/server/preparePostPurchaseDeclineDisplay.ts
-var import_zod87 = require("zod");
+var import_zod88 = require("zod");
 
 // src/schema/postPurchaseDecline.ts
-var import_zod86 = require("zod");
+var import_zod87 = require("zod");
 var OfferDeclineRequestSchema = DecideRequestSchema.extend({
   entryRevision: PostPurchaseProgressSchema.shape.entryRevision,
   productId: PostPurchaseProgressSchema.shape.members.element.shape.productId,
@@ -8044,13 +8090,13 @@ var OfferDeclineRequestSchema = DecideRequestSchema.extend({
   "Selected merchandise requires a variant"
 );
 var RecordedOfferDeclineSchema = PostPurchaseProgressSchema.shape.members.element.omit({ declineDelivery: true, status: true }).extend({ entry: DecisionEntrySchema.strict(), entryRevision: PostPurchaseProgressSchema.shape.entryRevision }).strict();
-var OfferDeclineResponseSchema = import_zod86.z.object({
-  data: import_zod86.z.object({ decline: RecordedOfferDeclineSchema, progress: PostPurchaseProgressSchema }),
-  successful: import_zod86.z.literal(true)
+var OfferDeclineResponseSchema = import_zod87.z.object({
+  data: import_zod87.z.object({ decline: RecordedOfferDeclineSchema, progress: PostPurchaseProgressSchema }),
+  successful: import_zod87.z.literal(true)
 });
 
 // src/server/preparePostPurchaseDeclineDisplay.ts
-var Selection = import_zod87.z.object({
+var Selection = import_zod88.z.object({
   productId: OfferDeclineRequestSchema.shape.productId,
   variant: OfferDeclineRequestSchema.shape.variant.unwrap()
 });
@@ -8080,30 +8126,30 @@ var preparePostPurchaseGroupDeclineDisplay = (settings, response, requested, exc
 
 // src/server/preparePostPurchaseOfferPresentation.ts
 var import_compat8 = require("es-toolkit/compat");
-var import_zod89 = require("zod");
+var import_zod90 = require("zod");
 
 // src/schema/postPurchaseOfferPresentation.ts
-var import_zod88 = require("zod");
+var import_zod89 = require("zod");
 var language2 = PostPurchaseSettings.shape.language.shape.global.unwrap().unwrap();
-var PostPurchaseOfferPresentation = import_zod88.z.strictObject({
+var PostPurchaseOfferPresentation = import_zod89.z.strictObject({
   labels: language2.pick({ declineAll: true, declineThisOffer: true }),
   layout: PostPurchaseSettings.shape.offersLayout,
   sections: CABRootSection.nullable(),
   showDeclineAll: PostPurchaseSettings.shape.productOptions.shape.showDeclineAll
 });
 var OfferPresentationRequestSchema = DecideRequestSchema.strict();
-var OfferPresentationResponseSchema = import_zod88.z.object({
-  data: import_zod88.z.strictObject({
+var OfferPresentationResponseSchema = import_zod89.z.object({
+  data: import_zod89.z.strictObject({
     presentation: PostPurchaseOfferPresentation.nullable(),
     progress: PostPurchaseProgressSchema.nullable(),
     serverNow: PostPurchaseTimestampSchema
   }),
-  successful: import_zod88.z.literal(true)
+  successful: import_zod89.z.literal(true)
 });
 
 // src/server/preparePostPurchaseOfferPresentation.ts
 var FrameSettings = PostPurchaseSettings.pick({ language: true, offersLayout: true, productOptions: true }).extend({
-  blocks: import_zod89.z.array(import_zod89.z.unknown()).optional()
+  blocks: import_zod90.z.array(import_zod90.z.unknown()).optional()
 });
 var preparePostPurchaseOfferPresentation = (widgetId, settings, response, report) => {
   const { metadata } = PostPurchaseProductSource.pick({ metadata: true }).parse(deepCamelCase(response));
@@ -8268,7 +8314,7 @@ var postAnalyticsEvents = async (input, ctx) => {
 };
 
 // src/server/requestSchemas.ts
-var import_zod90 = require("zod");
+var import_zod91 = require("zod");
 var REQUEST_BOUNDS = {
   /** Cart-level attributes per cart. */
   CART_ATTRIBUTES_MAX: 100,
@@ -8299,42 +8345,42 @@ var REQUEST_BOUNDS = {
   /** Rich ads transaction lines — the engine's ads contract. */
   TRANSACTION_ITEMS_MAX: 50
 };
-var KeyValue = import_zod90.z.object({
-  key: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX),
-  value: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_VALUE_MAX).optional()
+var KeyValue = import_zod91.z.object({
+  key: import_zod91.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX),
+  value: import_zod91.z.string().max(REQUEST_BOUNDS.STRING_VALUE_MAX).optional()
 });
-var CartLineInputSchema = import_zod90.z.object({
-  productId: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
-  properties: import_zod90.z.array(KeyValue).max(REQUEST_BOUNDS.LINE_PROPERTIES_MAX).optional(),
-  quantity: import_zod90.z.number(),
-  subscriptionId: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  variantId: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX)
+var CartLineInputSchema = import_zod91.z.object({
+  productId: import_zod91.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  properties: import_zod91.z.array(KeyValue).max(REQUEST_BOUNDS.LINE_PROPERTIES_MAX).optional(),
+  quantity: import_zod91.z.number(),
+  subscriptionId: import_zod91.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  variantId: import_zod91.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX)
 });
-var CartInputSchema = import_zod90.z.object({
-  attributes: import_zod90.z.array(KeyValue).max(REQUEST_BOUNDS.CART_ATTRIBUTES_MAX).optional(),
+var CartInputSchema = import_zod91.z.object({
+  attributes: import_zod91.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_zod90.z.number().optional(),
+  currencyRate: import_zod91.z.number().optional(),
   /** Applied discount codes; the engine evaluates `discount_code` rules against them (sent as `[{code}]`). */
-  discountCodes: import_zod90.z.array(import_zod90.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX)).max(REQUEST_BOUNDS.DISCOUNT_CODES_MAX).optional(),
+  discountCodes: import_zod91.z.array(import_zod91.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_zod90.z.number().optional(),
-  items: import_zod90.z.array(CartLineInputSchema).max(REQUEST_BOUNDS.CART_ITEMS_MAX),
+  discountTotal: import_zod91.z.number().optional(),
+  items: import_zod91.z.array(CartLineInputSchema).max(REQUEST_BOUNDS.CART_ITEMS_MAX),
   /** Presentment subtotal in cents. */
-  subtotal: import_zod90.z.number()
+  subtotal: import_zod91.z.number()
 });
-var UserConfigInputSchema = import_zod90.z.object({ shop: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX) });
-var DataSourceInputSchema = import_zod90.z.object({
+var UserConfigInputSchema = import_zod91.z.object({ shop: import_zod91.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX) });
+var DataSourceInputSchema = import_zod91.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_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  companyLocationId: import_zod91.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
@@ -8343,16 +8389,16 @@ var DataSourceInputSchema = import_zod90.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_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).regex(/^[A-Za-z]{2}$/, "must be an ISO 3166-1 alpha-2 country code (e.g. CA)").transform((value) => value.toUpperCase()).optional(),
-  customerId: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  dataSourcePath: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX),
+  country: import_zod91.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_zod91.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  dataSourcePath: import_zod91.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_zod90.z.enum(["no", "yes"]).optional(),
-  integrations: import_zod90.z.record(import_zod90.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX), import_zod90.z.boolean()).refine((record) => Object.keys(record).length <= REQUEST_BOUNDS.INTEGRATION_KEYS_MAX, {
+  filterInputs: import_zod91.z.enum(["no", "yes"]).optional(),
+  integrations: import_zod91.z.record(import_zod91.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX), import_zod91.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(),
   /**
@@ -8365,31 +8411,31 @@ var DataSourceInputSchema = import_zod90.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_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).regex(/^[A-Za-z0-9-]+$/, "must be a single BCP-47 tag (e.g. fr-CA), not a q-value list").optional(),
-  limit: import_zod90.z.number().max(REQUEST_BOUNDS.LIMIT_MAX),
-  productType: import_zod90.z.enum(["both", "one-time", "subscription"]).optional(),
-  shop: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
-  visitorId: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
-});
-var GiftInputSchema = import_zod90.z.object({
-  cost: import_zod90.z.number(),
-  discounted: import_zod90.z.boolean(),
+  language: import_zod91.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_zod91.z.number().max(REQUEST_BOUNDS.LIMIT_MAX),
+  productType: import_zod91.z.enum(["both", "one-time", "subscription"]).optional(),
+  shop: import_zod91.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  visitorId: import_zod91.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
+});
+var GiftInputSchema = import_zod91.z.object({
+  cost: import_zod91.z.number(),
+  discounted: import_zod91.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_zod90.z.enum(GIFT_KINDS).default("gwp"),
-  lineId: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
-  productId: import_zod90.z.number(),
+  kind: import_zod91.z.enum(GIFT_KINDS).default("gwp"),
+  lineId: import_zod91.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  productId: import_zod91.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_zod90.z.number().int().min(1).default(1),
-  widgetId: import_zod90.z.number()
+  quantity: import_zod91.z.number().int().min(1).default(1),
+  widgetId: import_zod91.z.number()
 });
-var GiftValidationInputSchema = import_zod90.z.object({
+var GiftValidationInputSchema = import_zod91.z.object({
   cart: CartInputSchema,
   /**
    * Buyer's market country — threaded into the per-widget data-source evaluations, which forward it to
@@ -8398,25 +8444,25 @@ var GiftValidationInputSchema = import_zod90.z.object({
    * turns markets off); regex-bound and uppercase-normalized for the same reasons as
    * `DataSourceInputSchema`'s `country`.
    */
-  country: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).regex(/^[A-Za-z]{2}$/, "must be an ISO 3166-1 alpha-2 country code (e.g. CA)").transform((value) => value.toUpperCase()).optional(),
-  customerId: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  gifts: import_zod90.z.array(GiftInputSchema).max(REQUEST_BOUNDS.GIFTS_MAX),
+  country: import_zod91.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_zod91.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  gifts: import_zod91.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_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).regex(/^[A-Za-z0-9-]+$/, "must be a single BCP-47 tag (e.g. fr-CA), not a q-value list").optional(),
-  shop: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
-  visitorId: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
+  language: import_zod91.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_zod91.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  visitorId: import_zod91.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
 });
-var GiftAdjustmentSchema = import_zod90.z.object({
-  lineId: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
-  quantity: import_zod90.z.number().int().nonnegative()
+var GiftAdjustmentSchema = import_zod91.z.object({
+  lineId: import_zod91.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  quantity: import_zod91.z.number().int().nonnegative()
 });
-var GiftValidationResponseSchema = import_zod90.z.object({
-  adjust: import_zod90.z.array(GiftAdjustmentSchema).max(REQUEST_BOUNDS.GIFTS_MAX).default([]),
-  remove: import_zod90.z.array(import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX)).max(REQUEST_BOUNDS.GIFTS_MAX).refine(
+var GiftValidationResponseSchema = import_zod91.z.object({
+  adjust: import_zod91.z.array(GiftAdjustmentSchema).max(REQUEST_BOUNDS.GIFTS_MAX).default([]),
+  remove: import_zod91.z.array(import_zod91.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`"
   )
@@ -8427,47 +8473,47 @@ var GiftValidationResponseSchema = import_zod90.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_zod90.z.object({
-  id: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
-  priceCents: import_zod90.z.number(),
-  quantity: import_zod90.z.number(),
-  title: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX),
-  type: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX)
-});
-var MonetizeInputSchema = import_zod90.z.object({
+var MonetizeTransactionItemSchema = import_zod91.z.object({
+  id: import_zod91.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  priceCents: import_zod91.z.number(),
+  quantity: import_zod91.z.number(),
+  title: import_zod91.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX),
+  type: import_zod91.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX)
+});
+var MonetizeInputSchema = import_zod91.z.object({
   cart: CartInputSchema,
   /** Client-minted render-beacon correlation id; forwarded to the ads engine as `client_request_id`. */
-  clientRequestId: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  country: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  currency: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  clientRequestId: import_zod91.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  country: import_zod91.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  currency: import_zod91.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_zod90.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
-  customerFirstName: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
-  customerId: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  customerLastName: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
-  language: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  customerEmail: import_zod91.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
+  customerFirstName: import_zod91.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
+  customerId: import_zod91.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  customerLastName: import_zod91.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
+  language: import_zod91.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_zod90.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
+  orderName: import_zod91.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_zod90.z.enum(["customer_account", "order_status", "thank_you_page"]),
+  placement: import_zod91.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_zod90.z.string().max(REQUEST_BOUNDS.STRING_URL_MAX).optional(),
+  privacyPolicyUrl: import_zod91.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_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  shop: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  sessionId: import_zod91.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  shop: import_zod91.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_zod90.z.boolean().optional(),
-  timezone: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  testing: import_zod91.z.boolean().optional(),
+  timezone: import_zod91.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
   /** Decorated (numeric) order id → the ads `transaction_id`. */
-  transactionId: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  transactionId: import_zod91.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_zod90.z.array(MonetizeTransactionItemSchema).max(REQUEST_BOUNDS.TRANSACTION_ITEMS_MAX).optional(),
+  transactionItems: import_zod91.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_zod90.z.number().optional(),
-  visitorId: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  zipCode: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
+  transactionTotal: import_zod91.z.number().optional(),
+  visitorId: import_zod91.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  zipCode: import_zod91.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
 });
-var WidgetSettingsInputSchema = import_zod90.z.object({
+var WidgetSettingsInputSchema = import_zod91.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
@@ -8475,9 +8521,9 @@ var WidgetSettingsInputSchema = import_zod90.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_zod90.z.number().int().positive().optional().catch(void 0),
-  id: import_zod90.z.number(),
-  key: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  cacheKey: import_zod91.z.number().int().positive().optional().catch(void 0),
+  id: import_zod91.z.number(),
+  key: import_zod91.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`
@@ -8486,34 +8532,34 @@ var WidgetSettingsInputSchema = import_zod90.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_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  shop: import_zod91.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
   /** Stable per-buyer id; when present, enables sticky server-side A/B variant selection. */
-  visitorId: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
+  visitorId: import_zod91.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
 });
-var AnalyticsEventInputSchema = import_zod90.z.object({
-  name: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX),
-  properties: import_zod90.z.record(import_zod90.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX), import_zod90.z.unknown()).optional(),
-  sentAt: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
+var AnalyticsEventInputSchema = import_zod91.z.object({
+  name: import_zod91.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX),
+  properties: import_zod91.z.record(import_zod91.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX), import_zod91.z.unknown()).optional(),
+  sentAt: import_zod91.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
 });
-var AnalyticsSegmentsInputSchema = import_zod90.z.object({
-  device: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional().catch(void 0),
-  source: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional().catch(void 0),
-  visitor: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional().catch(void 0)
+var AnalyticsSegmentsInputSchema = import_zod91.z.object({
+  device: import_zod91.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional().catch(void 0),
+  source: import_zod91.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional().catch(void 0),
+  visitor: import_zod91.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional().catch(void 0)
 });
-var AnalyticsInputSchema = import_zod90.z.object({
+var AnalyticsInputSchema = import_zod91.z.object({
   /** Rebuy cart token (the `r_cart_token` cart attribute), when available — primary aggregation key. */
-  cartToken: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  cartToken: import_zod91.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
   /** Shopify checkout token, when available — drives cart/checkout aggregation downstream. */
-  checkoutToken: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  events: import_zod90.z.array(AnalyticsEventInputSchema).max(REQUEST_BOUNDS.EVENTS_MAX),
+  checkoutToken: import_zod91.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  events: import_zod91.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_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
-  visitorId: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  shop: import_zod91.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  visitorId: import_zod91.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
   /** The widget id (smartBlockId) the events belong to. */
-  widgetId: import_zod90.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
+  widgetId: import_zod91.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
 });