@rebuy/rebuy 3.54.0 → 3.55.0

package/dist/server/index.mjs

@@ -6008,7 +6008,7 @@ var validateGifts = async (input, ctx) => {
 
 // src/server/normalizePostPurchaseProduct.ts
 import { merge } from "es-toolkit/compat";
-import { z as z45 } from "zod";
+import { z as z46 } from "zod";
 
 // src/schema/postPurchaseProductSettings.ts
 import { z as z44 } from "zod";
@@ -6089,18 +6089,54 @@ var PostPurchaseProductSettings = PostPurchaseSettings.pick({
   subscription: z44.unknown().default(PostPurchaseSettings.shape.subscription.parse(void 0))
 });
 
+// src/server/readPostPurchaseProductSource.ts
+import { z as z45 } from "zod";
+var Envelope = PostPurchaseProductSource.extend({ data: z45.array(z45.unknown()) });
+var Product3 = PostPurchaseProductSource.shape.data.element;
+var Identified = z45.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 = z45.object({ type: z45.string() }).safeParse(overrides.discount);
+  const discount = z46.object({ type: z46.string() }).safeParse(overrides.discount);
   if (discount.success && discount.data.type === "fixed") {
-    overrides.discount = { ...z45.record(z45.string(), z45.unknown()).parse(overrides.discount), type: "fixed_amount" };
+    overrides.discount = { ...z46.record(z46.string(), z46.unknown()).parse(overrides.discount), type: "fixed_amount" };
   }
   const effective = PostPurchaseProductSettings.parse(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) => {
@@ -6125,52 +6161,52 @@ var postPurchasePlanDiscountPercentage = (price, adjustment) => {
 };
 
 // src/schema/postPurchasePlanCatalog.ts
-import { z as z48 } from "zod";
+import { z as z49 } from "zod";
 
 // src/schema/postPurchasePlanAdjustment.ts
-import { z as z47 } from "zod";
+import { z as z48 } from "zod";
 
 // src/schema/postPurchaseDiscount.ts
-import { z as z46 } from "zod";
-var Discount = z46.object({
-  amount: z46.number().nonnegative(),
-  title: z46.string(),
-  type: z46.enum(["none", "fixed_amount", "percentage"])
+import { z as z47 } from "zod";
+var Discount = z47.object({
+  amount: z47.number().nonnegative(),
+  title: z47.string(),
+  type: z47.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 = z47.object({
+var PostPurchasePlanAdjustment = z48.object({
   amount: PostPurchaseDiscount.shape.amount,
-  type: z47.enum(["percentage", "fixed_amount", "price"])
+  type: z48.enum(["percentage", "fixed_amount", "price"])
 }).refine(({ amount: amount2, type }) => type === "price" || validPostPurchaseDiscount({ amount: amount2, type }));
 
 // src/schema/postPurchasePlanCatalog.ts
-var PostPurchasePlanOption = z48.object({
+var PostPurchasePlanOption = z49.object({
   adjustment: PostPurchasePlanAdjustment.optional(),
   /** cab-checkout's `discountPercentage`: the plan's own whole-percent saving on the regular price (`{{subscriptionDiscount}}`). */
-  discountPercentage: z48.number().int().min(0).max(100).optional(),
-  id: z48.number().int().positive(),
-  intervalFrequency: z48.string().regex(/^[1-9]\d*$/).optional(),
-  intervalLabel: z48.string().min(1),
-  name: z48.string().min(1)
+  discountPercentage: z49.number().int().min(0).max(100).optional(),
+  id: z49.number().int().positive(),
+  intervalFrequency: z49.string().regex(/^[1-9]\d*$/).optional(),
+  intervalLabel: z49.string().min(1),
+  name: z49.string().min(1)
 });
-var PostPurchasePlanCatalog = z48.object({
-  plans: z48.array(PostPurchasePlanOption),
-  productId: z48.number().int().positive(),
-  requiresSellingPlan: z48.boolean(),
-  variantId: z48.number().int().positive()
+var PostPurchasePlanCatalog = z49.object({
+  plans: z49.array(PostPurchasePlanOption),
+  productId: z49.number().int().positive(),
+  requiresSellingPlan: z49.boolean(),
+  variantId: z49.number().int().positive()
 });
 
 // src/server/postPurchaseLegacyPlans.ts
-import { z as z50 } from "zod";
+import { z as z51 } from "zod";
 
 // src/server/postPurchasePlanAdjustment.ts
-import { z as z49 } from "zod";
-var SourceAdjustment = z49.object({
+import { z as z50 } from "zod";
+var SourceAdjustment = z50.object({
   amount: PostPurchaseProductSettings.shape.discount.shape.amount.unwrap(),
-  type: z49.enum(["percentage", "fixed_amount", "amount", "price", "none", "fixed"])
+  type: z50.enum(["percentage", "fixed_amount", "amount", "price", "none", "fixed"])
 });
 var readPostPurchasePlanAdjustment = (raw) => {
   const source2 = SourceAdjustment.parse(raw);
@@ -6189,13 +6225,13 @@ var readPostPurchasePlanAdjustment = (raw) => {
 var Plan = PostPurchasePlanOption.pick({ id: true, name: true }).extend({
   orderIntervalFrequency: PostPurchasePlanOption.shape.intervalFrequency.unwrap(),
   orderIntervalUnitType: PostPurchasePlanOption.shape.intervalLabel,
-  shopifyVariantId: z50.string().regex(/^[1-9]\d*$/).nullish()
+  shopifyVariantId: z51.string().regex(/^[1-9]\d*$/).nullish()
 });
-var Group = z50.object({
-  discountAmount: z50.unknown(),
-  discountType: z50.unknown(),
-  id: z50.number().int().positive(),
-  sellingPlans: z50.array(z50.object({ shopifyVariantId: Plan.shape.shopifyVariantId }).passthrough())
+var Group = z51.object({
+  discountAmount: z51.unknown(),
+  discountType: z51.unknown(),
+  id: z51.number().int().positive(),
+  sellingPlans: z51.array(z51.object({ shopifyVariantId: Plan.shape.shopifyVariantId }).passthrough())
 });
 var readPostPurchaseLegacyPlans = (raw, variantId) => {
   const group = Group.pick({ id: true, sellingPlans: true }).parse(raw);
@@ -6216,21 +6252,21 @@ var readPostPurchaseLegacyPlans = (raw, variantId) => {
 };
 
 // src/server/postPurchaseModernPlans.ts
-import { z as z51 } from "zod";
-var Groups = z51.array(
-  z51.object({
-    id: z51.string().min(1),
-    sellingPlans: z51.unknown()
+import { z as z52 } from "zod";
+var Groups = z52.array(
+  z52.object({
+    id: z52.string().min(1),
+    sellingPlans: z52.unknown()
   })
 );
-var Allocations = z51.array(z51.object({ sellingPlanGroupId: z51.string().min(1) })).default([]);
-var Plans = z51.array(
+var Allocations = z52.array(z52.object({ sellingPlanGroupId: z52.string().min(1) })).default([]);
+var Plans = z52.array(
   PostPurchasePlanOption.pick({ id: true, name: true }).extend({
-    options: z51.array(z51.object({ value: z51.string().min(1) })).min(1),
-    priceAdjustments: z51.array(z51.unknown())
+    options: z52.array(z52.object({ value: z52.string().min(1) })).min(1),
+    priceAdjustments: z52.array(z52.unknown())
   })
 );
-var FirstAdjustment = z51.object({
+var FirstAdjustment = z52.object({
   value: PostPurchaseProductSettings.shape.discount.shape.amount.unwrap(),
   valueType: PostPurchasePlanAdjustment.shape.type
 });
@@ -6253,8 +6289,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];
@@ -6285,72 +6322,72 @@ var projectPostPurchasePlanCatalog = (normalized, report) => {
 };
 
 // src/schema/postPurchaseSubscriptionProduct.ts
-import { z as z57 } from "zod";
+import { z as z58 } from "zod";
 
 // src/schema/postPurchaseProduct.ts
-import { z as z56 } from "zod";
+import { z as z57 } from "zod";
 
 // src/schema/postPurchaseProductDisplay.ts
-import { z as z54 } from "zod";
+import { z as z55 } from "zod";
 
 // src/schema/postPurchaseProductGallery.ts
-import { z as z52 } from "zod";
-var PostPurchaseProductGallery = z52.object({
+import { z as z53 } from "zod";
+var PostPurchaseProductGallery = z53.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: z52.boolean().optional(),
-  images: z52.array(
-    z52.object({
-      description: z52.string(),
-      id: z52.number().int().positive(),
-      source: z52.string(),
-      thumbnail: z52.string()
+  hasMultiple: z53.boolean().optional(),
+  images: z53.array(
+    z53.object({
+      description: z53.string(),
+      id: z53.number().int().positive(),
+      source: z53.string(),
+      thumbnail: z53.string()
     })
   ),
-  selectedImageId: z52.number().int().positive().optional()
+  selectedImageId: z53.number().int().positive().optional()
 });
 
 // src/schema/postPurchaseProductReviews.ts
-import { z as z53 } from "zod";
-var decimal = z53.union([
-  z53.number(),
-  z53.string().regex(/^\d+(?:\.\d+)?$/).transform(Number)
+import { z as z54 } from "zod";
+var decimal = z54.union([
+  z54.number(),
+  z54.string().regex(/^\d+(?:\.\d+)?$/).transform(Number)
 ]);
-var PostPurchaseCommonReviewRating = z53.object({ value: decimal.pipe(z53.number().min(0).max(5)) });
+var PostPurchaseCommonReviewRating = z54.object({ value: decimal.pipe(z54.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: z53.unknown().nonoptional(),
-  scale_min: z53.unknown().nonoptional()
+  scale_max: z54.unknown().nonoptional(),
+  scale_min: z54.unknown().nonoptional()
 });
-var PostPurchaseReviewCount = z53.string().regex(/^\d+(?:\.\d+)?$/).transform(Number).pipe(z53.number().int().nonnegative());
+var PostPurchaseReviewCount = z54.string().regex(/^\d+(?:\.\d+)?$/).transform(Number).pipe(z54.number().int().nonnegative());
 var PostPurchaseReviewStyles = PostPurchaseSettings.shape.styles.unwrap().extend({
-  strokeWidth: decimal.pipe(z53.number().nonnegative()).default(1)
+  strokeWidth: decimal.pipe(z54.number().nonnegative()).default(1)
 }).prefault({});
-var PostPurchaseProductReviews = z53.object({
-  color: z53.string(),
-  rating: z53.number().positive().max(5),
-  reviewCount: z53.number().int().nonnegative(),
-  reviewsPlural: z53.string(),
-  reviewsSingular: z53.string(),
-  size: z53.enum(["small", "medium", "large"]),
-  strokeColor: z53.string(),
-  strokeWidth: z53.number().nonnegative()
+var PostPurchaseProductReviews = z54.object({
+  color: z54.string(),
+  rating: z54.number().positive().max(5),
+  reviewCount: z54.number().int().nonnegative(),
+  reviewsPlural: z54.string(),
+  reviewsSingular: z54.string(),
+  size: z54.enum(["small", "medium", "large"]),
+  strokeColor: z54.string(),
+  strokeWidth: z54.number().nonnegative()
 });
 
 // src/schema/postPurchaseProductDisplay.ts
 var language = PostPurchaseSettings.shape.language;
-var PostPurchasePrimaryImageSource = z54.string().default(
+var PostPurchasePrimaryImageSource = z55.string().default(
   "https://cdn.shopify.com/shopifycloud/shopify/assets/no-image-2048-5e88c1b20e087fb7bbe9a3771824e743c244f437e4f8ba93bbf7b11b53f7824c.gif"
 );
-var PostPurchaseProductDisplay = z54.object({
+var PostPurchaseProductDisplay = z55.object({
   descriptionDocument: TiptapDocument.optional(),
   discountedFrom: PostPurchaseSettings.shape.discountedFrom,
   gallery: PostPurchaseProductGallery.optional(),
   language: language.pick({ description: true, descriptionEnabled: true }),
-  primaryImage: z54.object({ description: z54.string(), source: z54.string() }),
+  primaryImage: z55.object({ description: z55.string(), source: z55.string() }),
   productOptions: PostPurchaseSettings.shape.productOptions.pick({
     showDeclineAll: true,
     showShipping: true,
@@ -6365,14 +6402,14 @@ var PostPurchaseProductDisplay = z54.object({
 });
 
 // src/schema/postPurchaseSubscription.ts
-import { z as z55 } from "zod";
-var PostPurchaseSubscriptionTerms = z55.object({
+import { z as z56 } from "zod";
+var PostPurchaseSubscriptionTerms = z56.object({
   adjustment: PostPurchasePlanAdjustment.optional(),
-  initialShippingPrice: z55.number().nonnegative(),
-  intervalLabel: z55.string().min(1),
-  name: z55.string().min(1),
-  recurringShippingPrice: z55.number().nonnegative(),
-  shippingOption: z55.object({ presentmentTitle: z55.string(), title: z55.string() })
+  initialShippingPrice: z56.number().nonnegative(),
+  intervalLabel: z56.string().min(1),
+  name: z56.string().min(1),
+  recurringShippingPrice: z56.number().nonnegative(),
+  shippingOption: z56.object({ presentmentTitle: z56.string(), title: z56.string() })
 });
 
 // src/schema/postPurchaseProduct.ts
@@ -6382,52 +6419,52 @@ var PostPurchaseVariant = OfferProduct.shape.variants.element.pick({ id: true, t
   id: PostPurchaseVariantId,
   price: PostPurchaseAmount
 });
-var PreparedPostPurchaseProduct = z56.object({
+var PreparedPostPurchaseProduct = z57.object({
   display: PostPurchaseProductDisplay,
-  labels: z56.object({
+  labels: z57.object({
     declineAll: global.declineAll,
-    free: z56.string(),
+    free: z57.string(),
     notAvailable: global.notAvailable,
-    payNow: z56.string(),
-    quantity: z56.string(),
+    payNow: z57.string(),
+    quantity: z57.string(),
     recurringShipping: global.recurringShipping,
     recurringSubtotal: global.recurringSubtotal,
-    save: z56.string(),
-    shipping: z56.string(),
-    subtotal: z56.string(),
-    taxes: z56.string(),
-    total: z56.string()
+    save: z57.string(),
+    shipping: z57.string(),
+    subtotal: z57.string(),
+    taxes: z57.string(),
+    total: z57.string()
   }),
   product: OfferProduct.pick({ description: true, id: true, image: true, title: true }).extend({
     description: OfferProduct.shape.description.nullable(),
     id: PostPurchaseProductId,
     variant: PostPurchaseVariant
   }),
-  selection: z56.object({
+  selection: z57.object({
     productId: PostPurchaseProductId,
-    quantity: z56.number().int().positive(),
-    sellingPlanId: z56.number().int().positive().optional(),
+    quantity: z57.number().int().positive(),
+    sellingPlanId: z57.number().int().positive().optional(),
     variantId: PostPurchaseVariantId
   }),
-  status: z56.literal("prepared"),
-  terms: z56.object({
+  status: z57.literal("prepared"),
+  terms: z57.object({
     discount: PostPurchaseDiscount,
-    shipping: z56.object({
-      amount: z56.number().nonnegative(),
-      title: z56.string(),
-      type: z56.enum(["free", "fixed_amount"])
+    shipping: z57.object({
+      amount: z57.number().nonnegative(),
+      title: z57.string(),
+      type: z57.enum(["free", "fixed_amount"])
     }),
     subscription: PostPurchaseSubscriptionTerms.optional()
   })
 });
-var PostPurchasePreparation = z56.discriminatedUnion("status", [
+var PostPurchasePreparation = z57.discriminatedUnion("status", [
   PreparedPostPurchaseProduct,
-  z56.object({ reason: z56.string(), status: z56.literal("unsupported") })
+  z57.object({ reason: z57.string(), status: z57.literal("unsupported") })
 ]);
 
 // src/schema/postPurchaseSubscriptionProduct.ts
 var PreparedPostPurchaseSubscription = PreparedPostPurchaseProduct.extend({
-  selection: PreparedPostPurchaseProduct.shape.selection.extend({ sellingPlanId: z57.number().int().positive() }),
+  selection: PreparedPostPurchaseProduct.shape.selection.extend({ sellingPlanId: z58.number().int().positive() }),
   terms: PreparedPostPurchaseProduct.shape.terms.extend({
     subscription: PostPurchaseSubscriptionTerms
   }).refine(
@@ -6486,7 +6523,7 @@ var subscriptionUnavailable = (normalized, plan, allowCollection, quantity3) =>
 };
 
 // src/server/postPurchaseProductDisplay.ts
-import { z as z59 } from "zod";
+import { z as z60 } from "zod";
 
 // src/server/postPurchasePrimaryImage.ts
 var postPurchasePrimaryImage = (product) => {
@@ -6512,7 +6549,7 @@ var postPurchaseProductGallery = (product, limit) => {
 };
 
 // src/transforms/postPurchase/convertDescriptionRte.ts
-import { z as z58 } from "zod";
+import { z as z59 } from "zod";
 var alignments = { center: "center", left: "start", right: "end" };
 var colors = ["critical", "subdued", "success", "warning"];
 var sizes2 = ["extraSmall", "small", "medium", "large", "extraLarge"];
@@ -6524,19 +6561,19 @@ var spacings2 = {
   xloose: "extraLoose",
   xtight: "extraTight"
 };
-var Block = z58.object({
-  attrs: z58.object({ alignment: z58.enum(["left", "center", "right"]).optional().catch(void 0) }).catch({}),
-  content: z58.array(z58.unknown()).catch([]),
-  type: z58.literal("ShopifyTextBlock")
-});
-var Run = z58.object({ marks: z58.array(z58.unknown()).catch([]), text: z58.string().min(1), type: z58.literal("text") });
-var Inline = z58.object({
-  attrs: z58.object({
-    color: z58.enum(colors).optional().catch(void 0),
-    emphasis: z58.array(z58.unknown()).catch([]),
-    size: z58.enum(sizes2).optional().catch(void 0)
+var Block = z59.object({
+  attrs: z59.object({ alignment: z59.enum(["left", "center", "right"]).optional().catch(void 0) }).catch({}),
+  content: z59.array(z59.unknown()).catch([]),
+  type: z59.literal("ShopifyTextBlock")
+});
+var Run = z59.object({ marks: z59.array(z59.unknown()).catch([]), text: z59.string().min(1), type: z59.literal("text") });
+var Inline = z59.object({
+  attrs: z59.object({
+    color: z59.enum(colors).optional().catch(void 0),
+    emphasis: z59.array(z59.unknown()).catch([]),
+    size: z59.enum(sizes2).optional().catch(void 0)
   }),
-  type: z58.literal("ShopifyTextInline")
+  type: z59.literal("ShopifyTextInline")
 });
 var marks = (raw) => {
   const found = raw.map((mark) => Inline.safeParse(mark)).find(({ success }) => success)?.data;
@@ -6569,7 +6606,7 @@ var convertDescriptionRte = (rte, spacing) => TiptapDocument.parse({
 });
 
 // src/server/postPurchaseProductDisplay.ts
-var ResponseLanguage = z59.object({ description: PostPurchaseProductDisplay.shape.responseDescription }).default({ description: "" });
+var ResponseLanguage = z60.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,
@@ -6582,16 +6619,16 @@ var projectPostPurchaseProductDisplay = (effective, metadata, product) => PostPu
 });
 
 // src/server/postPurchaseReviewData.ts
-import { z as z64 } from "zod";
+import { z as z65 } from "zod";
 
 // src/server/postPurchaseJudgeMeReviews.ts
-import { z as z61 } from "zod";
+import { z as z62 } from "zod";
 
 // src/server/postPurchaseReviewFields.ts
-import { z as z60 } from "zod";
-var Field = z60.object({ key: z60.string(), namespace: z60.string(), value: z60.unknown().optional() });
+import { z as z61 } from "zod";
+var Field = z61.object({ key: z61.string(), namespace: z61.string(), value: z61.unknown().optional() });
 var reviewFields = (raw) => {
-  const fields4 = z60.array(z60.unknown()).parse(raw).flatMap((field) => {
+  const fields4 = z61.array(z61.unknown()).parse(raw).flatMap((field) => {
     const parsed = Field.safeParse(field);
     return parsed.success ? [parsed.data] : [];
   });
@@ -6616,7 +6653,7 @@ var readJudgeMeReviews = (find) => {
   const field = find("judgeme", "badge");
   if (!field) return null;
   return readReviewField(field, (value) => {
-    const html = z61.string().parse(value);
+    const html = z62.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");
@@ -6628,20 +6665,20 @@ var readJudgeMeReviews = (find) => {
 };
 
 // src/server/postPurchaseOkendoReviews.ts
-import { z as z62 } from "zod";
-var Summary = z62.object({
+import { z as z63 } from "zod";
+var Summary = z63.object({
   reviewAverageValue: PostPurchaseCommonReviewRating.shape.value,
-  reviewCount: z62.union([PostPurchaseProductReviews.shape.reviewCount, PostPurchaseReviewCount])
+  reviewCount: z63.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(z62.string().parse(value))));
+  const summary = readReviewField(field, (value) => Summary.parse(JSON.parse(z63.string().parse(value))));
   return { rating: summary.reviewAverageValue, reviewCount: summary.reviewCount };
 };
 
 // src/server/postPurchaseScalarReviews.ts
-import { z as z63 } from "zod";
+import { z as z64 } from "zod";
 var readScalarReviews = (find, namespace, ratingKey, countKey) => {
   const rating = find(namespace, ratingKey);
   const count = find(namespace, countKey);
@@ -6649,7 +6686,7 @@ var readScalarReviews = (find, namespace, ratingKey, countKey) => {
   return {
     rating: readReviewField(
       rating,
-      (value) => PostPurchaseCommonReviewRating.parse({ value: z63.string().parse(value) }).value
+      (value) => PostPurchaseCommonReviewRating.parse({ value: z64.string().parse(value) }).value
     ),
     reviewCount: readReviewField(count, (value) => PostPurchaseReviewCount.parse(value))
   };
@@ -6662,7 +6699,7 @@ var readStandardReviews = (find) => {
   if (!rating || !count) return null;
   return {
     rating: readReviewField(rating, (raw) => {
-      const value = z64.string().parse(raw);
+      const value = z65.string().parse(raw);
       return PostPurchaseCommonReviewRating.parse(/^\d+(?:\.\d+)?$/.test(value) ? { value } : JSON.parse(value)).value;
     }),
     reviewCount: readReviewField(count, (value) => PostPurchaseReviewCount.parse(value))
@@ -6684,15 +6721,15 @@ var readPostPurchaseReviewData = (provider, find) => {
   return {
     rating: readReviewField(
       rating,
-      (value) => PostPurchaseKlaviyoReviewRating.parse(JSON.parse(z64.string().parse(value))).value
+      (value) => PostPurchaseKlaviyoReviewRating.parse(JSON.parse(z65.string().parse(value))).value
     ),
     reviewCount: readReviewField(count, (value) => PostPurchaseReviewCount.parse(value))
   };
 };
 
 // src/server/postPurchaseReviewProvider.ts
-import { z as z65 } from "zod";
-var IntegrationInput = z65.record(z65.string(), z65.unknown()).prefault({});
+import { z as z66 } from "zod";
+var IntegrationInput = z66.record(z66.string(), z66.unknown()).prefault({});
 var precedence = [
   "klaviyo",
   "judgeme",
@@ -6704,7 +6741,7 @@ var precedence = [
   "stamped",
   "yotpo"
 ];
-var ReviewsIoFlag = z65.preprocess((value) => {
+var ReviewsIoFlag = z66.preprocess((value) => {
   if (typeof value === "string") {
     const flag = value.toLowerCase();
     if (flag === "true" || flag === "yes") return true;
@@ -6805,7 +6842,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,
@@ -6843,42 +6880,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
-import { z as z72 } from "zod";
+import { z as z73 } from "zod";
 
 // src/schema/postPurchaseChoice.ts
-import { z as z66 } from "zod";
-var PostPurchaseChoice = z66.discriminatedUnion("mode", [
-  z66.object({ mode: z66.literal("one-time") }).strict(),
-  z66.object({ mode: z66.literal("subscription"), sellingPlanId: PostPurchasePlanOption.shape.id }).strict()
+import { z as z67 } from "zod";
+var PostPurchaseChoice = z67.discriminatedUnion("mode", [
+  z67.object({ mode: z67.literal("one-time") }).strict(),
+  z67.object({ mode: z67.literal("subscription"), sellingPlanId: PostPurchasePlanOption.shape.id }).strict()
 ]);
-var PostPurchaseOptions = z66.object({
+var PostPurchaseOptions = z67.object({
   defaultChoice: PostPurchaseChoice,
-  modes: z66.array(z66.enum(["one-time", "subscription"])).min(1).max(2),
+  modes: z67.array(z67.enum(["one-time", "subscription"])).min(1).max(2),
   selector: PostPurchaseSettings.shape.productTypeSelector
 });
 
 // src/schema/postPurchaseDisplayPrice.ts
-import { z as z68 } from "zod";
+import { z as z69 } from "zod";
 
 // src/schema/postPurchaseSubscriptionDisplay.ts
-import { z as z67 } from "zod";
-var Minor = z67.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
-var PostPurchaseSubscriptionDisplay = z67.object({
+import { z as z68 } from "zod";
+var Minor = z68.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+var PostPurchaseSubscriptionDisplay = z68.object({
   comparisonMinor: Minor,
-  currencyCode: z67.string().regex(/^[A-Z]{3}$/),
+  currencyCode: z68.string().regex(/^[A-Z]{3}$/),
   priceMinor: Minor,
   savingMinor: Minor,
-  savingPercent: z67.number().int().min(0).max(100)
+  savingPercent: z68.number().int().min(0).max(100)
 });
 
 // src/schema/postPurchaseDisplayPrice.ts
 var { currencyCode: CurrencyCode, priceMinor: Minor2, savingPercent: Percent } = PostPurchaseSubscriptionDisplay.shape;
-var PostPurchaseDisplayPrice = z68.object({
+var PostPurchaseDisplayPrice = z69.object({
   currencyCode: CurrencyCode,
-  savingFormat: z68.enum(["amount", "percent"]).nullable(),
+  savingFormat: z69.enum(["amount", "percent"]).nullable(),
   savingMinor: Minor2,
   savingPercent: Percent,
   subscriptionUnit: PostPurchaseSubscriptionDisplay.optional(),
@@ -6896,30 +6933,30 @@ var PostPurchaseDisplayPrice = z68.object({
 );
 
 // src/schema/postPurchaseGroupCatalog.ts
-import { z as z70 } from "zod";
+import { z as z71 } from "zod";
 
 // src/schema/postPurchaseVariantCatalog.ts
-import { z as z69 } from "zod";
-var PostPurchaseVariantSelector = z69.object({ variantId: PostPurchaseVariantId }).strict();
+import { z as z70 } from "zod";
+var PostPurchaseVariantSelector = z70.object({ variantId: PostPurchaseVariantId }).strict();
 var PostPurchaseVariantOption = OfferProduct.shape.options.element.extend({
-  id: z69.number().int().positive().optional(),
-  position: z69.number().int().min(1).max(3)
+  id: z70.number().int().positive().optional(),
+  position: z70.number().int().min(1).max(3)
 });
 var PostPurchaseVariantValues = OfferProduct.shape.variants.element.pick({
   option1: true,
   option2: true,
   option3: true
 });
-var PostPurchaseVariantCatalog = z69.object({
+var PostPurchaseVariantCatalog = z70.object({
   displayMode: PostPurchaseSettings.shape.productOptions.shape.variantSelectorDisplayMode,
-  options: z69.array(PostPurchaseVariantOption),
+  options: z70.array(PostPurchaseVariantOption),
   productId: PostPurchaseProductId,
   showSelectors: PostPurchaseSettings.shape.productOptions.shape.showVariantSelectors,
-  variants: z69.array(
+  variants: z70.array(
     PostPurchaseVariantValues.partial().extend({
-      available: z69.boolean(),
+      available: z70.boolean(),
       id: PostPurchaseVariantId,
-      imageId: z69.number().int().nonnegative().nullish(),
+      imageId: z70.number().int().nonnegative().nullish(),
       title: OfferProduct.shape.variants.element.shape.title
     })
   )
@@ -6933,89 +6970,89 @@ var PostPurchaseGroupDescription = source.pick({ description: true, id: true, im
   image: source.shape.image.default(null),
   options: PostPurchaseVariantCatalog.shape.options.default([])
 });
-var PostPurchaseGroupCatalog = z70.object({
+var PostPurchaseGroupCatalog = z71.object({
   memberProductId: productId,
-  options: z70.array(z70.object({ productId, title: z70.string(), variantCatalog: PostPurchaseVariantCatalog }))
+  options: z71.array(z71.object({ productId, title: z71.string(), variantCatalog: PostPurchaseVariantCatalog }))
 });
-var PostPurchaseGroupSelection = z70.object({
+var PostPurchaseGroupSelection = z71.object({
   memberProductId: productId,
   productId
 });
 
 // src/schema/postPurchaseProductCalculation.ts
-import { z as z71 } from "zod";
-var MoneyBag = z71.object({
-  presentmentMoney: z71.object({
+import { z as z72 } from "zod";
+var MoneyBag = z72.object({
+  presentmentMoney: z72.object({
     amount: PostPurchaseAmount,
-    currencyCode: z71.string().regex(/^[A-Z]{3}$/)
+    currencyCode: z72.string().regex(/^[A-Z]{3}$/)
   })
 });
-var PostPurchaseProductCalculation = z71.object({
-  calculatedPurchase: z71.object({
-    addedShippingLines: z71.array(z71.object({ priceSet: MoneyBag })),
-    addedTaxLines: z71.array(z71.object({ priceSet: MoneyBag })),
+var PostPurchaseProductCalculation = z72.object({
+  calculatedPurchase: z72.object({
+    addedShippingLines: z72.array(z72.object({ priceSet: MoneyBag })),
+    addedTaxLines: z72.array(z72.object({ priceSet: MoneyBag })),
     totalOutstandingSet: MoneyBag,
-    updatedLineItems: z71.array(
-      z71.object({
-        priceSet: z71.unknown().optional(),
-        productId: z71.number().int().positive(),
-        sellingPlanId: z71.unknown().optional(),
-        variantId: z71.number().int().positive()
+    updatedLineItems: z72.array(
+      z72.object({
+        priceSet: z72.unknown().optional(),
+        productId: z72.number().int().positive(),
+        sellingPlanId: z72.unknown().optional(),
+        variantId: z72.number().int().positive()
       })
     )
   }),
-  errors: z71.array(z71.unknown()).length(0),
-  status: z71.literal("processed")
+  errors: z72.array(z72.unknown()).length(0),
+  status: z72.literal("processed")
 });
-var Minor3 = z71.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
-var PostPurchaseProductCosts = z71.object({
+var Minor3 = z72.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+var PostPurchaseProductCosts = z72.object({
   currencyCode: MoneyBag.shape.presentmentMoney.shape.currencyCode,
-  recurringDisplay: z71.object({ shippingMinor: Minor3, subtotalMinor: Minor3, totalMinor: Minor3 }).optional(),
+  recurringDisplay: z72.object({ shippingMinor: Minor3, subtotalMinor: Minor3, totalMinor: Minor3 }).optional(),
   shippingMinor: Minor3,
   subtotalMinor: Minor3,
   taxesMinor: Minor3,
   totalMinor: Minor3
 });
-var ChangesetDiscount = z71.object({
-  title: z71.string(),
-  value: z71.number().nonnegative(),
-  valueType: z71.enum(["percentage", "fixed_amount"])
+var ChangesetDiscount = z72.object({
+  title: z72.string(),
+  value: z72.number().nonnegative(),
+  valueType: z72.enum(["percentage", "fixed_amount"])
 }).optional();
-var PostPurchaseProductChangeset = z71.object({
-  changes: z71.array(
-    z71.union([
-      z71.object({
+var PostPurchaseProductChangeset = z72.object({
+  changes: z72.array(
+    z72.union([
+      z72.object({
         discount: ChangesetDiscount,
-        quantity: z71.number().int().positive(),
-        type: z71.literal("add_variant"),
-        variantId: z71.number().int().positive()
+        quantity: z72.number().int().positive(),
+        type: z72.literal("add_variant"),
+        variantId: z72.number().int().positive()
       }),
-      z71.object({ price: z71.number().nonnegative(), title: z71.string(), type: z71.literal("add_shipping_line") }),
+      z72.object({ price: z72.number().nonnegative(), title: z72.string(), type: z72.literal("add_shipping_line") }),
       PostPurchaseSubscriptionTerms.pick({
         initialShippingPrice: true,
         recurringShippingPrice: true,
         shippingOption: true
       }).extend({
         discount: ChangesetDiscount,
-        quantity: z71.number().int().positive(),
-        sellingPlanId: z71.number().int().positive(),
-        type: z71.literal("add_subscription"),
-        variantId: z71.number().int().positive()
+        quantity: z72.number().int().positive(),
+        sellingPlanId: z72.number().int().positive(),
+        type: z72.literal("add_subscription"),
+        variantId: z72.number().int().positive()
       })
     ])
   )
 });
 
 // src/schema/postPurchaseProductView.ts
-var PostPurchaseProductView = z72.union([
-  z72.object({
+var PostPurchaseProductView = z73.union([
+  z73.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: z72.string().nullable() }).refine(
+      display: PreparedPostPurchaseProduct.shape.display.extend({ description: z73.string().nullable() }).refine(
         ({ description, descriptionDocument }) => description === null === (descriptionDocument !== void 0),
         "Exactly one of the plain and rich descriptions is shown"
       )
@@ -7024,7 +7061,7 @@ var PostPurchaseProductView = z72.union([
     sections: CABRootSection,
     variantCatalog: PostPurchaseVariantCatalog.optional()
   }),
-  z72.object({
+  z73.object({
     groupCatalog: PostPurchaseGroupCatalog.optional(),
     initialVariant: PostPurchaseVariantSelector.optional(),
     /** The localized unavailable copy, for the choices still offered beneath an unprepared product. */
@@ -7039,12 +7076,12 @@ var PostPurchaseProductView = z72.union([
 ]);
 
 // src/server/postPurchaseOfferCopy.ts
-import { z as z73 } from "zod";
-var Copy = z73.object({
+import { z as z74 } from "zod";
+var Copy = z74.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 = z73.object({ settings: z73.record(z73.string(), z73.unknown()), type: z73.literal("callout_banner") });
+var Callout = z74.object({ settings: z74.record(z74.string(), z74.unknown()), type: z74.literal("callout_banner") });
 var postPurchaseOfferCopy = (blocks, metadata) => {
   const copy = Copy.safeParse(metadata.widget.language);
   if (!blocks || !copy.success) return blocks;
@@ -7078,7 +7115,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;
@@ -7148,72 +7185,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
-import { z as z80 } from "zod";
+import { z as z81 } from "zod";
 
 // src/schema/postPurchaseProgress.ts
-import { z as z79 } from "zod";
+import { z as z80 } from "zod";
 
 // src/schema/postPurchaseDeclineDelivery.ts
-import { z as z78 } from "zod";
+import { z as z79 } from "zod";
 
 // src/schema/postPurchaseAcceptedEvent.ts
-import { z as z77 } from "zod";
+import { z as z78 } from "zod";
 
 // src/schema/postPurchaseAdmission.ts
-import { z as z76 } from "zod";
+import { z as z77 } from "zod";
 
 // src/schema/postPurchaseIdentity.ts
-import { z as z74 } from "zod";
+import { z as z75 } from "zod";
 var POST_PURCHASE_ID_MAX = 128;
-var PostPurchaseTimestampSchema = z74.number().int().nonnegative();
-var PostPurchaseOrderIdSchema = z74.string().regex(/^gid:\/\/shopify\/Order\/[1-9]\d*$/);
-var ShopifyDomainSchema = z74.string().max(POST_PURCHASE_ID_MAX).regex(/^[a-z0-9]([a-z0-9-]*[a-z0-9])?\.myshopify\.com$/);
-var DecideRequestSchema = z74.object({
-  checkoutToken: z74.string().min(1).max(POST_PURCHASE_ID_MAX),
+var PostPurchaseTimestampSchema = z75.number().int().nonnegative();
+var PostPurchaseOrderIdSchema = z75.string().regex(/^gid:\/\/shopify\/Order\/[1-9]\d*$/);
+var ShopifyDomainSchema = z75.string().max(POST_PURCHASE_ID_MAX).regex(/^[a-z0-9]([a-z0-9-]*[a-z0-9])?\.myshopify\.com$/);
+var DecideRequestSchema = z75.object({
+  checkoutToken: z75.string().min(1).max(POST_PURCHASE_ID_MAX),
   shop: ShopifyDomainSchema
 });
-var PostPurchaseAppIdSchema = z74.string().min(1).max(POST_PURCHASE_ID_MAX);
-var DecisionEntrySchema = z74.object({
-  blockId: z74.number().int().positive(),
-  blockIndex: z74.string(),
-  blockParentIndex: z74.string(),
-  flowId: z74.number().int().positive(),
-  sectionId: z74.number().int().positive(),
-  widgetId: z74.number().int().positive(),
-  widgetTraffic: z74.number().min(0).max(100)
+var PostPurchaseAppIdSchema = z75.string().min(1).max(POST_PURCHASE_ID_MAX);
+var DecisionEntrySchema = z75.object({
+  blockId: z75.number().int().positive(),
+  blockIndex: z75.string(),
+  blockParentIndex: z75.string(),
+  flowId: z75.number().int().positive(),
+  sectionId: z75.number().int().positive(),
+  widgetId: z75.number().int().positive(),
+  widgetTraffic: z75.number().min(0).max(100)
 });
 
 // src/schema/postPurchaseMemberIdentity.ts
-import { z as z75 } from "zod";
-var PostPurchaseMemberIdentity = z75.object({
-  productId: z75.number().int().positive(),
-  productIndex: z75.number().int().nonnegative()
+import { z as z76 } from "zod";
+var PostPurchaseMemberIdentity = z76.object({
+  productId: z76.number().int().positive(),
+  productIndex: z76.number().int().nonnegative()
 }).strict();
 
 // src/schema/postPurchaseAdmission.ts
-var PurchaseAdmissionModeSchema = z76.enum(["purchase", "sts"]);
+var PurchaseAdmissionModeSchema = z77.enum(["purchase", "sts"]);
 var selection = PreparedPostPurchaseProduct.shape.selection;
 var EventCalculationSchema = PostPurchaseProductCosts.pick({ currencyCode: true, totalMinor: true }).strict();
-var PurchaseExpectedSchema = z76.object({
-  buyerConsentToSubscriptions: z76.boolean().optional(),
+var PurchaseExpectedSchema = z77.object({
+  buyerConsentToSubscriptions: z77.boolean().optional(),
   changeset: PostPurchaseProductChangeset.extend({
     changes: PostPurchaseProductChangeset.shape.changes.min(1).max(2)
   }),
   entry: DecisionEntrySchema,
   member: PostPurchaseMemberIdentity.optional(),
   mode: PurchaseAdmissionModeSchema.optional(),
-  progressRevision: z76.number().int().nonnegative().optional(),
+  progressRevision: z77.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.
@@ -7234,16 +7276,16 @@ var PurchaseExpectedSchema = z76.object({
 }, "Selection, change and buyer consent must agree");
 var PurchaseRequestSchema = DecideRequestSchema.extend({
   expected: PurchaseExpectedSchema,
-  requestId: z76.uuid()
+  requestId: z77.uuid()
 }).strict();
-var PurchaseReceiptSchema = z76.object({
+var PurchaseReceiptSchema = z77.object({
   admittedAt: PostPurchaseTimestampSchema,
-  changesetToken: z76.string().min(1),
+  changesetToken: z77.string().min(1),
   mode: PurchaseAdmissionModeSchema.optional(),
-  operationId: z76.uuid(),
+  operationId: z77.uuid(),
   /** The server-bound one-time line an STS refunds; its quantity is the order's, not the selection's. */
-  originalLine: z76.strictObject({ quantity: selection.shape.quantity, variantId: selection.shape.variantId }).optional(),
-  requiresSubscriptionConsent: z76.boolean(),
+  originalLine: z77.strictObject({ quantity: selection.shape.quantity, variantId: selection.shape.variantId }).optional(),
+  requiresSubscriptionConsent: z77.boolean(),
   selection
 }).refine(
   ({ requiresSubscriptionConsent, selection: selection4 }) => requiresSubscriptionConsent === (selection4.sellingPlanId !== void 0),
@@ -7252,14 +7294,14 @@ var PurchaseReceiptSchema = z76.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 = z76.object({ data: PurchaseReceiptSchema, successful: z76.literal(true) });
+var PurchaseResponseSchema = z77.object({ data: PurchaseReceiptSchema, successful: z77.literal(true) });
 
 // src/schema/postPurchaseAcceptedEvent.ts
-var AcceptedEventOutcomeSchema = z77.enum(["acknowledged", "rejected", "skipped", "unknown"]);
-var AttemptProgressSchema = z77.strictObject({
+var AcceptedEventOutcomeSchema = z78.enum(["acknowledged", "rejected", "skipped", "unknown"]);
+var AttemptProgressSchema = z78.strictObject({
   attemptedAt: PostPurchaseTimestampSchema,
   reportedCalculation: EventCalculationSchema,
-  status: z77.literal("attempted")
+  status: z78.literal("attempted")
 });
 var AcceptedEventAttemptProgressSchema = AttemptProgressSchema.extend({
   operationId: PurchaseReceiptSchema.shape.operationId
@@ -7272,17 +7314,17 @@ var AcceptedEventRequestSchema = DecideRequestSchema.extend({
   operationId: PurchaseReceiptSchema.shape.operationId,
   reportedCalculation: EventCalculationSchema
 }).strict();
-var AcceptedEventResponseSchema = z77.object({
-  data: z77.union([AcceptedEventAttemptProgressSchema, AcceptedEventResultProgressSchema]),
-  successful: z77.literal(true)
+var AcceptedEventResponseSchema = z78.object({
+  data: z78.union([AcceptedEventAttemptProgressSchema, AcceptedEventResultProgressSchema]),
+  successful: z78.literal(true)
 });
 
 // src/schema/postPurchaseDeclineDelivery.ts
-var AttemptSchema = z78.strictObject({
+var AttemptSchema = z79.strictObject({
   attemptedAt: PostPurchaseTimestampSchema,
-  status: z78.enum(["attempted", "unavailable"])
+  status: z79.enum(["attempted", "unavailable"])
 });
-var DeclineDeliveryProgressSchema = z78.union([
+var DeclineDeliveryProgressSchema = z79.union([
   AttemptSchema,
   AttemptSchema.extend({
     finishedAt: PostPurchaseTimestampSchema,
@@ -7291,36 +7333,36 @@ var DeclineDeliveryProgressSchema = z78.union([
 ]);
 
 // src/schema/postPurchaseProgress.ts
-var PostPurchaseProgressSchema = z79.object({
+var PostPurchaseProgressSchema = z80.object({
   closedAt: PostPurchaseTimestampSchema.nullable(),
   deadline: PostPurchaseTimestampSchema,
   entry: DecisionEntrySchema,
-  entryRevision: z79.number().int().nonnegative(),
-  members: z79.array(
+  entryRevision: z80.number().int().nonnegative(),
+  members: z80.array(
     PostPurchaseMemberIdentity.extend({
       declineDelivery: DeclineDeliveryProgressSchema.optional(),
-      status: z79.enum(["unhandled", "accepted", "declined"])
+      status: z80.enum(["unhandled", "accepted", "declined"])
     }).strict()
   ),
-  revision: z79.number().int().nonnegative()
+  revision: z80.number().int().nonnegative()
 }).strict();
 
 // src/schema/postPurchaseProductCollectionView.ts
-var PostPurchaseProductCollectionView = z80.object({
-  members: z80.array(
-    z80.object({
+var PostPurchaseProductCollectionView = z81.object({
+  members: z81.array(
+    z81.object({
       productId: PostPurchaseProductId,
-      productIndex: z80.number().int().nonnegative(),
+      productIndex: z81.number().int().nonnegative(),
       view: PostPurchaseProductView
     })
   )
 });
-var PostPurchaseCollectionChoice = z80.object({
+var PostPurchaseCollectionChoice = z81.object({
   choice: PostPurchaseChoice.optional(),
   productId: PostPurchaseProductId,
   variantId: PostPurchaseVariantSelector.shape.variantId.optional()
 }).strict();
-var PostPurchaseExcludedProductIds = z80.array(PostPurchaseProductId).default([]);
+var PostPurchaseExcludedProductIds = z81.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,
@@ -7328,16 +7370,19 @@ var PostPurchaseMemberPointer = PostPurchaseProgressSchema.shape.members.element
 });
 
 // src/server/normalizePostPurchaseCollection.ts
-import { z as z81 } from "zod";
-var normalizePostPurchaseCollection = (settings, response, excludedProductIds) => {
-  const normalized = normalizePostPurchaseProduct(settings, response);
-  const limit = z81.number().int().positive();
+import { z as z82, ZodError } from "zod";
+var normalizePostPurchaseCollection = (settings, response, excludedProductIds, report) => {
+  const { dropped, normalized, products } = normalizePostPurchaseSource(settings, response, report);
+  const limit = z82.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 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 };
 };
 
@@ -7375,40 +7420,40 @@ var projectPostPurchaseVariantCatalog = (product, settings) => {
 };
 
 // src/schema/postPurchaseOfferEligibility.ts
-import { z as z82 } from "zod";
+import { z as z83 } from "zod";
 var selection2 = PreparedPostPurchaseProduct.shape.selection;
-var PostPurchaseOfferSkipReason = z82.enum(["empty", "no-eligible-subscription"]);
-var PostPurchaseOfferEligibilityContext = z82.object({
+var PostPurchaseOfferSkipReason = z83.enum(["empty", "no-eligible-subscription"]);
+var PostPurchaseOfferEligibilityContext = z83.object({
   excludedProductIds: PostPurchaseExcludedProductIds,
-  originalLineItems: z82.array(selection2.pick({ productId: true, sellingPlanId: true, variantId: true }))
+  originalLineItems: z83.array(selection2.pick({ productId: true, sellingPlanId: true, variantId: true }))
 });
-var PostPurchaseStsOptions = z82.object({ sts: z82.boolean().optional() }).strict();
-var PostPurchaseStsContext = z82.object({
-  originalLineItems: z82.array(
+var PostPurchaseStsOptions = z83.object({ sts: z83.boolean().optional() }).strict();
+var PostPurchaseStsContext = z83.object({
+  originalLineItems: z83.array(
     selection2.pick({ productId: true, quantity: true, sellingPlanId: true, variantId: true })
   )
 });
-var PostPurchaseOfferEligibility = z82.discriminatedUnion("status", [
-  z82.object({
-    members: z82.array(
-      z82.object({ productId: selection2.shape.productId, productIndex: z82.number().int().nonnegative() })
+var PostPurchaseOfferEligibility = z83.discriminatedUnion("status", [
+  z83.object({
+    members: z83.array(
+      z83.object({ productId: selection2.shape.productId, productIndex: z83.number().int().nonnegative() })
     ),
     /** Present only with STS on: each member switches one original one-time line to subscription. */
-    mode: z82.literal("sts").optional(),
-    status: z82.literal("retain")
+    mode: z83.literal("sts").optional(),
+    status: z83.literal("retain")
   }),
-  z82.object({ reason: PostPurchaseOfferSkipReason, status: z82.literal("skip") }),
-  z82.object({ reason: z82.literal("eligible-sts").optional(), status: z82.literal("unavailable") })
+  z83.object({ reason: PostPurchaseOfferSkipReason, status: z83.literal("skip") }),
+  z83.object({ reason: z83.literal("eligible-sts").optional(), status: z83.literal("unavailable") })
 ]);
 
 // src/schema/postPurchaseQuantity.ts
-import { z as z83 } from "zod";
+import { z as z84 } from "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: z83.literal(0).transform(() => 1).or(quantity2)
+  minValue: z84.literal(0).transform(() => 1).or(quantity2)
 }).refine(({ maxValue, minValue }) => minValue <= maxValue, "Quantity bounds are reversed");
 
 // src/server/readPostPurchaseQuantity.ts
@@ -7476,7 +7521,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);
@@ -7487,39 +7532,39 @@ var preparePostPurchaseStsMember = (widgetId, settings, response, selected, sts,
 };
 
 // src/schema/postPurchaseVariantDefault.ts
-import { z as z84 } from "zod";
+import { z as z85 } from "zod";
 var values = PostPurchaseVariantValues.partial().extend({
   option1: PostPurchaseVariantValues.shape.option1.nullish()
 });
 var variant = values.extend({
   id: PostPurchaseVariantId,
-  inventoryManagement: z84.string().nullable(),
-  inventoryPolicy: z84.string(),
-  inventoryQuantity: z84.number()
+  inventoryManagement: z85.string().nullable(),
+  inventoryPolicy: z85.string(),
+  inventoryQuantity: z85.number()
 });
-var options = z84.array(PostPurchaseVariantOption.pick({ name: true, values: true }));
-var PostPurchaseVariantDefaultProduct = z84.object({
+var options = z85.array(PostPurchaseVariantOption.pick({ name: true, values: true }));
+var PostPurchaseVariantDefaultProduct = z85.object({
   id: PostPurchaseProductId,
   options,
   selectedVariant: variant.optional(),
-  variants: z84.array(variant)
+  variants: z85.array(variant)
 });
 var PostPurchaseVariantDefaultSettings = PostPurchaseSettings.shape.productOptions.pick({
   hideOutOfStockVariants: true,
   matchVariant: true
 });
-var PostPurchaseOrderAttributes = z84.record(z84.string(), z84.array(z84.string())).default({});
-var PostPurchaseOriginalVariants = z84.array(
-  z84.object({ productId: PostPurchaseProductId, variantId: PostPurchaseVariantId })
+var PostPurchaseOrderAttributes = z85.record(z85.string(), z85.array(z85.string())).default({});
+var PostPurchaseOriginalVariants = z85.array(
+  z85.object({ productId: PostPurchaseProductId, variantId: PostPurchaseVariantId })
 );
-var PostPurchaseAttributeProducts = z84.array(
-  z84.object({ id: PostPurchaseProductId, options, variants: z84.array(values.extend({ id: PostPurchaseVariantId })) })
+var PostPurchaseAttributeProducts = z85.array(
+  z85.object({ id: PostPurchaseProductId, options, variants: z85.array(values.extend({ id: PostPurchaseVariantId })) })
 );
 
 // src/schema/postPurchaseVariantDefaultContext.ts
-import { z as z85 } from "zod";
-var PostPurchaseVariantDefaultContext = z85.object({
-  enrichedLineItems: z85.unknown().optional(),
+import { z as z86 } from "zod";
+var PostPurchaseVariantDefaultContext = z86.object({
+  enrichedLineItems: z86.unknown().optional(),
   originalVariants: PostPurchaseOriginalVariants
 });
 
@@ -7598,7 +7643,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));
@@ -7772,7 +7817,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);
@@ -7831,7 +7876,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;
@@ -7957,10 +8002,10 @@ var classifyPostPurchaseOffer = (settings, response, context, options2) => {
 };
 
 // src/server/preparePostPurchaseDeclineDisplay.ts
-import { z as z87 } from "zod";
+import { z as z88 } from "zod";
 
 // src/schema/postPurchaseDecline.ts
-import { z as z86 } from "zod";
+import { z as z87 } from "zod";
 var OfferDeclineRequestSchema = DecideRequestSchema.extend({
   entryRevision: PostPurchaseProgressSchema.shape.entryRevision,
   productId: PostPurchaseProgressSchema.shape.members.element.shape.productId,
@@ -7972,13 +8017,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 = z86.object({
-  data: z86.object({ decline: RecordedOfferDeclineSchema, progress: PostPurchaseProgressSchema }),
-  successful: z86.literal(true)
+var OfferDeclineResponseSchema = z87.object({
+  data: z87.object({ decline: RecordedOfferDeclineSchema, progress: PostPurchaseProgressSchema }),
+  successful: z87.literal(true)
 });
 
 // src/server/preparePostPurchaseDeclineDisplay.ts
-var Selection = z87.object({
+var Selection = z88.object({
   productId: OfferDeclineRequestSchema.shape.productId,
   variant: OfferDeclineRequestSchema.shape.variant.unwrap()
 });
@@ -8008,30 +8053,30 @@ var preparePostPurchaseGroupDeclineDisplay = (settings, response, requested, exc
 
 // src/server/preparePostPurchaseOfferPresentation.ts
 import { merge as merge2 } from "es-toolkit/compat";
-import { z as z89 } from "zod";
+import { z as z90 } from "zod";
 
 // src/schema/postPurchaseOfferPresentation.ts
-import { z as z88 } from "zod";
+import { z as z89 } from "zod";
 var language2 = PostPurchaseSettings.shape.language.shape.global.unwrap().unwrap();
-var PostPurchaseOfferPresentation = z88.strictObject({
+var PostPurchaseOfferPresentation = z89.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 = z88.object({
-  data: z88.strictObject({
+var OfferPresentationResponseSchema = z89.object({
+  data: z89.strictObject({
     presentation: PostPurchaseOfferPresentation.nullable(),
     progress: PostPurchaseProgressSchema.nullable(),
     serverNow: PostPurchaseTimestampSchema
   }),
-  successful: z88.literal(true)
+  successful: z89.literal(true)
 });
 
 // src/server/preparePostPurchaseOfferPresentation.ts
 var FrameSettings = PostPurchaseSettings.pick({ language: true, offersLayout: true, productOptions: true }).extend({
-  blocks: z89.array(z89.unknown()).optional()
+  blocks: z90.array(z90.unknown()).optional()
 });
 var preparePostPurchaseOfferPresentation = (widgetId, settings, response, report) => {
   const { metadata } = PostPurchaseProductSource.pick({ metadata: true }).parse(deepCamelCase(response));
@@ -8196,7 +8241,7 @@ var postAnalyticsEvents = async (input, ctx) => {
 };
 
 // src/server/requestSchemas.ts
-import { z as z90 } from "zod";
+import { z as z91 } from "zod";
 var REQUEST_BOUNDS = {
   /** Cart-level attributes per cart. */
   CART_ATTRIBUTES_MAX: 100,
@@ -8227,42 +8272,42 @@ var REQUEST_BOUNDS = {
   /** Rich ads transaction lines — the engine's ads contract. */
   TRANSACTION_ITEMS_MAX: 50
 };
-var KeyValue = z90.object({
-  key: z90.string().max(REQUEST_BOUNDS.STRING_KEY_MAX),
-  value: z90.string().max(REQUEST_BOUNDS.STRING_VALUE_MAX).optional()
+var KeyValue = z91.object({
+  key: z91.string().max(REQUEST_BOUNDS.STRING_KEY_MAX),
+  value: z91.string().max(REQUEST_BOUNDS.STRING_VALUE_MAX).optional()
 });
-var CartLineInputSchema = z90.object({
-  productId: z90.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
-  properties: z90.array(KeyValue).max(REQUEST_BOUNDS.LINE_PROPERTIES_MAX).optional(),
-  quantity: z90.number(),
-  subscriptionId: z90.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  variantId: z90.string().max(REQUEST_BOUNDS.STRING_ID_MAX)
+var CartLineInputSchema = z91.object({
+  productId: z91.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  properties: z91.array(KeyValue).max(REQUEST_BOUNDS.LINE_PROPERTIES_MAX).optional(),
+  quantity: z91.number(),
+  subscriptionId: z91.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  variantId: z91.string().max(REQUEST_BOUNDS.STRING_ID_MAX)
 });
-var CartInputSchema = z90.object({
-  attributes: z90.array(KeyValue).max(REQUEST_BOUNDS.CART_ATTRIBUTES_MAX).optional(),
+var CartInputSchema = z91.object({
+  attributes: z91.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: z90.number().optional(),
+  currencyRate: z91.number().optional(),
   /** Applied discount codes; the engine evaluates `discount_code` rules against them (sent as `[{code}]`). */
-  discountCodes: z90.array(z90.string().max(REQUEST_BOUNDS.STRING_KEY_MAX)).max(REQUEST_BOUNDS.DISCOUNT_CODES_MAX).optional(),
+  discountCodes: z91.array(z91.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: z90.number().optional(),
-  items: z90.array(CartLineInputSchema).max(REQUEST_BOUNDS.CART_ITEMS_MAX),
+  discountTotal: z91.number().optional(),
+  items: z91.array(CartLineInputSchema).max(REQUEST_BOUNDS.CART_ITEMS_MAX),
   /** Presentment subtotal in cents. */
-  subtotal: z90.number()
+  subtotal: z91.number()
 });
-var UserConfigInputSchema = z90.object({ shop: z90.string().max(REQUEST_BOUNDS.STRING_ID_MAX) });
-var DataSourceInputSchema = z90.object({
+var UserConfigInputSchema = z91.object({ shop: z91.string().max(REQUEST_BOUNDS.STRING_ID_MAX) });
+var DataSourceInputSchema = z91.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: z90.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  companyLocationId: z91.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
@@ -8271,16 +8316,16 @@ var DataSourceInputSchema = z90.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: z90.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: z90.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  dataSourcePath: z90.string().max(REQUEST_BOUNDS.STRING_KEY_MAX),
+  country: z91.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: z91.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  dataSourcePath: z91.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: z90.enum(["no", "yes"]).optional(),
-  integrations: z90.record(z90.string().max(REQUEST_BOUNDS.STRING_KEY_MAX), z90.boolean()).refine((record) => Object.keys(record).length <= REQUEST_BOUNDS.INTEGRATION_KEYS_MAX, {
+  filterInputs: z91.enum(["no", "yes"]).optional(),
+  integrations: z91.record(z91.string().max(REQUEST_BOUNDS.STRING_KEY_MAX), z91.boolean()).refine((record) => Object.keys(record).length <= REQUEST_BOUNDS.INTEGRATION_KEYS_MAX, {
     message: `Too many integration keys (max ${REQUEST_BOUNDS.INTEGRATION_KEYS_MAX})`
   }).optional(),
   /**
@@ -8293,31 +8338,31 @@ var DataSourceInputSchema = z90.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: z90.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: z90.number().max(REQUEST_BOUNDS.LIMIT_MAX),
-  productType: z90.enum(["both", "one-time", "subscription"]).optional(),
-  shop: z90.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
-  visitorId: z90.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
-});
-var GiftInputSchema = z90.object({
-  cost: z90.number(),
-  discounted: z90.boolean(),
+  language: z91.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: z91.number().max(REQUEST_BOUNDS.LIMIT_MAX),
+  productType: z91.enum(["both", "one-time", "subscription"]).optional(),
+  shop: z91.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  visitorId: z91.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
+});
+var GiftInputSchema = z91.object({
+  cost: z91.number(),
+  discounted: z91.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: z90.enum(GIFT_KINDS).default("gwp"),
-  lineId: z90.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
-  productId: z90.number(),
+  kind: z91.enum(GIFT_KINDS).default("gwp"),
+  lineId: z91.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  productId: z91.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: z90.number().int().min(1).default(1),
-  widgetId: z90.number()
+  quantity: z91.number().int().min(1).default(1),
+  widgetId: z91.number()
 });
-var GiftValidationInputSchema = z90.object({
+var GiftValidationInputSchema = z91.object({
   cart: CartInputSchema,
   /**
    * Buyer's market country — threaded into the per-widget data-source evaluations, which forward it to
@@ -8326,25 +8371,25 @@ var GiftValidationInputSchema = z90.object({
    * turns markets off); regex-bound and uppercase-normalized for the same reasons as
    * `DataSourceInputSchema`'s `country`.
    */
-  country: z90.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: z90.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  gifts: z90.array(GiftInputSchema).max(REQUEST_BOUNDS.GIFTS_MAX),
+  country: z91.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: z91.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  gifts: z91.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: z90.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: z90.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
-  visitorId: z90.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
+  language: z91.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: z91.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  visitorId: z91.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
 });
-var GiftAdjustmentSchema = z90.object({
-  lineId: z90.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
-  quantity: z90.number().int().nonnegative()
+var GiftAdjustmentSchema = z91.object({
+  lineId: z91.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  quantity: z91.number().int().nonnegative()
 });
-var GiftValidationResponseSchema = z90.object({
-  adjust: z90.array(GiftAdjustmentSchema).max(REQUEST_BOUNDS.GIFTS_MAX).default([]),
-  remove: z90.array(z90.string().max(REQUEST_BOUNDS.STRING_ID_MAX)).max(REQUEST_BOUNDS.GIFTS_MAX).refine(
+var GiftValidationResponseSchema = z91.object({
+  adjust: z91.array(GiftAdjustmentSchema).max(REQUEST_BOUNDS.GIFTS_MAX).default([]),
+  remove: z91.array(z91.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`"
   )
@@ -8355,47 +8400,47 @@ var GiftValidationResponseSchema = z90.object({
   ({ adjust }) => new Set(adjust.map(({ lineId }) => lineId)).size === adjust.length,
   "a line id may appear at most once in `adjust`"
 );
-var MonetizeTransactionItemSchema = z90.object({
-  id: z90.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
-  priceCents: z90.number(),
-  quantity: z90.number(),
-  title: z90.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX),
-  type: z90.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX)
-});
-var MonetizeInputSchema = z90.object({
+var MonetizeTransactionItemSchema = z91.object({
+  id: z91.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  priceCents: z91.number(),
+  quantity: z91.number(),
+  title: z91.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX),
+  type: z91.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX)
+});
+var MonetizeInputSchema = z91.object({
   cart: CartInputSchema,
   /** Client-minted render-beacon correlation id; forwarded to the ads engine as `client_request_id`. */
-  clientRequestId: z90.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  country: z90.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  currency: z90.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  clientRequestId: z91.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  country: z91.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  currency: z91.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
   /** Ads-targeting identity/geo/locale fields (React parity); folded into the engine query verbatim. */
-  customerEmail: z90.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
-  customerFirstName: z90.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
-  customerId: z90.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  customerLastName: z90.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
-  language: z90.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  customerEmail: z91.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
+  customerFirstName: z91.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
+  customerId: z91.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  customerLastName: z91.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
+  language: z91.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
   /** Buyer-facing order name (e.g. `#1001`) for the server-composed "Order … Confirmed" chrome line. */
-  orderName: z90.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
+  orderName: z91.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: z90.enum(["customer_account", "order_status", "thank_you_page"]),
+  placement: z91.enum(["customer_account", "order_status", "thank_you_page"]),
   /** Privacy Policy footer href — the Monetize widget's `privacy_policy_url` setting (React parity). */
-  privacyPolicyUrl: z90.string().max(REQUEST_BOUNDS.STRING_URL_MAX).optional(),
+  privacyPolicyUrl: z91.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: z90.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  shop: z90.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  sessionId: z91.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  shop: z91.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: z90.boolean().optional(),
-  timezone: z90.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  testing: z91.boolean().optional(),
+  timezone: z91.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
   /** Decorated (numeric) order id → the ads `transaction_id`. */
-  transactionId: z90.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  transactionId: z91.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: z90.array(MonetizeTransactionItemSchema).max(REQUEST_BOUNDS.TRANSACTION_ITEMS_MAX).optional(),
+  transactionItems: z91.array(MonetizeTransactionItemSchema).max(REQUEST_BOUNDS.TRANSACTION_ITEMS_MAX).optional(),
   /** Order total in presentment cents (React prefers total over subtotal); else `cart.subtotal`. */
-  transactionTotal: z90.number().optional(),
-  visitorId: z90.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  zipCode: z90.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
+  transactionTotal: z91.number().optional(),
+  visitorId: z91.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  zipCode: z91.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
 });
-var WidgetSettingsInputSchema = z90.object({
+var WidgetSettingsInputSchema = z91.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
@@ -8403,9 +8448,9 @@ var WidgetSettingsInputSchema = z90.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: z90.number().int().positive().optional().catch(void 0),
-  id: z90.number(),
-  key: z90.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  cacheKey: z91.number().int().positive().optional().catch(void 0),
+  id: z91.number(),
+  key: z91.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`
@@ -8414,36 +8459,36 @@ var WidgetSettingsInputSchema = z90.object({
    * `privacyPolicyUrl` comes from the widget settings server-side (more authoritative than a relay).
    */
   monetize: MonetizeInputSchema.omit({ privacyPolicyUrl: true, shop: true }).optional(),
-  shop: z90.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  shop: z91.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
   /** Stable per-buyer id; when present, enables sticky server-side A/B variant selection. */
-  visitorId: z90.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
+  visitorId: z91.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
 });
-var AnalyticsEventInputSchema = z90.object({
-  name: z90.string().max(REQUEST_BOUNDS.STRING_KEY_MAX),
-  properties: z90.record(z90.string().max(REQUEST_BOUNDS.STRING_KEY_MAX), z90.unknown()).optional(),
-  sentAt: z90.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
+var AnalyticsEventInputSchema = z91.object({
+  name: z91.string().max(REQUEST_BOUNDS.STRING_KEY_MAX),
+  properties: z91.record(z91.string().max(REQUEST_BOUNDS.STRING_KEY_MAX), z91.unknown()).optional(),
+  sentAt: z91.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
 });
-var AnalyticsSegmentsInputSchema = z90.object({
-  device: z90.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional().catch(void 0),
-  source: z90.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional().catch(void 0),
-  visitor: z90.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional().catch(void 0)
+var AnalyticsSegmentsInputSchema = z91.object({
+  device: z91.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional().catch(void 0),
+  source: z91.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional().catch(void 0),
+  visitor: z91.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional().catch(void 0)
 });
-var AnalyticsInputSchema = z90.object({
+var AnalyticsInputSchema = z91.object({
   /** Rebuy cart token (the `r_cart_token` cart attribute), when available — primary aggregation key. */
-  cartToken: z90.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  cartToken: z91.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
   /** Shopify checkout token, when available — drives cart/checkout aggregation downstream. */
-  checkoutToken: z90.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  events: z90.array(AnalyticsEventInputSchema).max(REQUEST_BOUNDS.EVENTS_MAX),
+  checkoutToken: z91.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  events: z91.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: z90.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
-  visitorId: z90.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  shop: z91.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  visitorId: z91.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
   /** The widget id (smartBlockId) the events belong to. */
-  widgetId: z90.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
+  widgetId: z91.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
 });
 export {
   AnalyticsEventInputSchema,
@@ -8490,6 +8535,7 @@ export {
   preparePostPurchaseSubscription,
   preparePostPurchaseView,
   readPostPurchaseGroupSelection,
+  readPostPurchaseProductSource,
   readPostPurchaseQuantity,
   translateAnalyticsEvent,
   validateGifts