@rebuy/rebuy 3.35.0 → 3.37.0

package/dist/server/index.cjs

@@ -47,9 +47,20 @@ __export(server_exports, {
   fetchMonetizeOffers: () => fetchMonetizeOffers,
   fetchUserConfig: () => fetchUserConfig,
   postAnalyticsEvents: () => postAnalyticsEvents,
+  preparePostPurchaseAdmissionView: () => preparePostPurchaseAdmissionView,
+  preparePostPurchaseCollectionView: () => preparePostPurchaseCollectionView,
+  preparePostPurchaseGroupAdmissionView: () => preparePostPurchaseGroupAdmissionView,
   preparePostPurchaseGroupDeclineDisplay: () => preparePostPurchaseGroupDeclineDisplay,
+  preparePostPurchaseGroupDefault: () => preparePostPurchaseGroupDefault,
+  preparePostPurchaseGroupView: () => preparePostPurchaseGroupView,
+  preparePostPurchaseMemberAdmissionView: () => preparePostPurchaseMemberAdmissionView,
+  preparePostPurchaseMemberView: () => preparePostPurchaseMemberView,
   preparePostPurchaseOfferPresentation: () => preparePostPurchaseOfferPresentation,
+  preparePostPurchaseProduct: () => preparePostPurchaseProduct,
+  preparePostPurchaseQuantityAdmissionView: () => preparePostPurchaseQuantityAdmissionView,
+  preparePostPurchaseQuantityView: () => preparePostPurchaseQuantityView,
   preparePostPurchaseSubscription: () => preparePostPurchaseSubscription,
+  preparePostPurchaseView: () => preparePostPurchaseView,
   readPostPurchaseGroupSelection: () => readPostPurchaseGroupSelection,
   readPostPurchaseQuantity: () => readPostPurchaseQuantity,
   translateAnalyticsEvent: () => translateAnalyticsEvent,
@@ -2178,7 +2189,7 @@ var stripContentBlockHtml = (text2) => text2.replace(HTML_COMMENT_RE, "").replac
 var convertTextToTiptapParagraph = ({
   color,
   fontSize,
-  marks = [],
+  marks: marks2 = [],
   text: text2,
   textAlign
 }) => {
@@ -2187,7 +2198,7 @@ var convertTextToTiptapParagraph = ({
     attrs: { textAlign },
     content: sanitizedText ? [
       {
-        marks: [{ attrs: { color, fontSize }, type: "textStyle" }, ...marks],
+        marks: [{ attrs: { color, fontSize }, type: "textStyle" }, ...marks2],
         text: sanitizedText,
         type: "text"
       }
@@ -2644,11 +2655,11 @@ var pushText = (state, rawText) => {
   decodeTextEntities(rawText).split("\n").forEach((segment, index) => {
     if (index > 0) flushParagraph(state);
     if (!segment) return;
-    const marks = state.stack.flatMap((entry) => entry.marks);
-    if (state.defaultTextStyleMark && !marks.some((mark) => mark.type === "textStyle")) {
-      marks.push(state.defaultTextStyleMark);
+    const marks2 = state.stack.flatMap((entry) => entry.marks);
+    if (state.defaultTextStyleMark && !marks2.some((mark) => mark.type === "textStyle")) {
+      marks2.push(state.defaultTextStyleMark);
     }
-    state.currentRuns.push(TiptapText.parse(marks.length > 0 ? { marks, text: segment } : { text: segment }));
+    state.currentRuns.push(TiptapText.parse(marks2.length > 0 ? { marks: marks2, text: segment } : { text: segment }));
   });
 };
 
@@ -3223,10 +3234,10 @@ var SWITCH_LABEL_TOKENS2 = ["subscriptionDiscount", "frequency", "interval"];
 var QUANTITY_ERROR_TOKENS = ["max", "min", "step"];
 var VARIANT_SELECTOR = { button: "button", radio: "radio", select: "menu" };
 var buildStyledText = (token, style, fontSize = style?.textSize ?? "base") => {
-  const marks = [{ attrs: { color: "base", fontSize }, type: "textStyle" }];
-  if (style?.textEmphasis === "bold") marks.push({ type: "bold" });
-  if (style?.textEmphasis === "italic") marks.push({ type: "italic" });
-  return { content: [{ content: [{ marks, text: token, type: "text" }], type: "paragraph" }], type: "doc" };
+  const marks2 = [{ attrs: { color: "base", fontSize }, type: "textStyle" }];
+  if (style?.textEmphasis === "bold") marks2.push({ type: "bold" });
+  if (style?.textEmphasis === "italic") marks2.push({ type: "italic" });
+  return { content: [{ content: [{ marks: marks2, text: token, type: "text" }], type: "paragraph" }], type: "doc" };
 };
 var buildPriceContent = () => ({
   content: [
@@ -5948,13 +5959,13 @@ var projectPostPurchasePlanCatalog = (normalized, report) => {
 };
 
 // src/schema/postPurchaseSubscriptionProduct.ts
-var import_zod54 = require("zod");
+var import_zod55 = require("zod");
 
 // src/schema/postPurchaseProduct.ts
-var import_zod53 = require("zod");
+var import_zod54 = require("zod");
 
 // src/schema/postPurchaseProductDisplay.ts
-var import_zod51 = require("zod");
+var import_zod52 = require("zod");
 
 // src/schema/postPurchaseProductGallery.ts
 var import_zod50 = require("zod");
@@ -5970,21 +5981,44 @@ var PostPurchaseProductGallery = import_zod50.z.object({
   selectedImageId: import_zod50.z.number().int().positive().optional()
 });
 
+// src/schema/postPurchaseProductReviews.ts
+var import_zod51 = require("zod");
+var decimal = import_zod51.z.union([
+  import_zod51.z.number(),
+  import_zod51.z.string().regex(/^\d+(?:\.\d+)?$/).transform(Number)
+]);
+var PostPurchaseCommonReviewRating = import_zod51.z.object({ value: decimal.pipe(import_zod51.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_zod51.z.unknown().nonoptional(),
+  scale_min: import_zod51.z.unknown().nonoptional()
+});
+var PostPurchaseReviewCount = import_zod51.z.string().regex(/^\d+(?:\.\d+)?$/).transform(Number).pipe(import_zod51.z.number().int().nonnegative());
+var PostPurchaseReviewStyles = PostPurchaseSettings.shape.styles.unwrap().extend({
+  strokeWidth: decimal.pipe(import_zod51.z.number().nonnegative()).default(1)
+}).prefault({});
+var PostPurchaseProductReviews = import_zod51.z.object({
+  color: import_zod51.z.string(),
+  rating: import_zod51.z.number().positive().max(5),
+  reviewCount: import_zod51.z.number().int().nonnegative(),
+  reviewsPlural: import_zod51.z.string(),
+  reviewsSingular: import_zod51.z.string(),
+  size: import_zod51.z.enum(["small", "medium", "large"]),
+  strokeColor: import_zod51.z.string(),
+  strokeWidth: import_zod51.z.number().nonnegative()
+});
+
 // src/schema/postPurchaseProductDisplay.ts
 var language = PostPurchaseSettings.shape.language;
-var PostPurchasePrimaryImageSource = import_zod51.z.string().default(
+var PostPurchasePrimaryImageSource = import_zod52.z.string().default(
   "https://cdn.shopify.com/shopifycloud/shopify/assets/no-image-2048-5e88c1b20e087fb7bbe9a3771824e743c244f437e4f8ba93bbf7b11b53f7824c.gif"
 );
-var PostPurchaseProductDisplay = import_zod51.z.object({
+var PostPurchaseProductDisplay = import_zod52.z.object({
+  descriptionDocument: TiptapDocument.optional(),
   discountedFrom: PostPurchaseSettings.shape.discountedFrom,
   gallery: PostPurchaseProductGallery.optional(),
-  language: language.pick({
-    description: true,
-    descriptionEnabled: true,
-    descriptionRte: true,
-    descriptionSpacing: true
-  }),
-  primaryImage: import_zod51.z.object({ description: import_zod51.z.string(), source: import_zod51.z.string() }),
+  language: language.pick({ description: true, descriptionEnabled: true }),
+  primaryImage: import_zod52.z.object({ description: import_zod52.z.string(), source: import_zod52.z.string() }),
   productOptions: PostPurchaseSettings.shape.productOptions.pick({
     showDeclineAll: true,
     showShipping: true,
@@ -5994,18 +6028,19 @@ var PostPurchaseProductDisplay = import_zod51.z.object({
     showVariantSelectors: true
   }),
   responseDescription: language.shape.description,
+  reviews: PostPurchaseProductReviews.nullable().default(null),
   shouldShowSavingText: PostPurchaseSettings.shape.discount.shape.shouldShowSavingText
 });
 
 // src/schema/postPurchaseSubscription.ts
-var import_zod52 = require("zod");
-var PostPurchaseSubscriptionTerms = import_zod52.z.object({
+var import_zod53 = require("zod");
+var PostPurchaseSubscriptionTerms = import_zod53.z.object({
   adjustment: PostPurchasePlanAdjustment.optional(),
-  initialShippingPrice: import_zod52.z.number().nonnegative(),
-  intervalLabel: import_zod52.z.string().min(1),
-  name: import_zod52.z.string().min(1),
-  recurringShippingPrice: import_zod52.z.number().nonnegative(),
-  shippingOption: import_zod52.z.object({ presentmentTitle: import_zod52.z.string(), title: import_zod52.z.string() })
+  initialShippingPrice: import_zod53.z.number().nonnegative(),
+  intervalLabel: import_zod53.z.string().min(1),
+  name: import_zod53.z.string().min(1),
+  recurringShippingPrice: import_zod53.z.number().nonnegative(),
+  shippingOption: import_zod53.z.object({ presentmentTitle: import_zod53.z.string(), title: import_zod53.z.string() })
 });
 
 // src/schema/postPurchaseProduct.ts
@@ -6015,51 +6050,51 @@ var PostPurchaseVariant = OfferProduct.shape.variants.element.pick({ id: true, t
   id: PostPurchaseVariantId,
   price: PostPurchaseAmount
 });
-var PreparedPostPurchaseProduct = import_zod53.z.object({
+var PreparedPostPurchaseProduct = import_zod54.z.object({
   display: PostPurchaseProductDisplay,
-  labels: import_zod53.z.object({
+  labels: import_zod54.z.object({
     declineAll: global.declineAll,
-    free: import_zod53.z.string(),
-    payNow: import_zod53.z.string(),
-    quantity: import_zod53.z.string(),
+    free: import_zod54.z.string(),
+    payNow: import_zod54.z.string(),
+    quantity: import_zod54.z.string(),
     recurringShipping: global.recurringShipping,
     recurringSubtotal: global.recurringSubtotal,
-    save: import_zod53.z.string(),
-    shipping: import_zod53.z.string(),
-    subtotal: import_zod53.z.string(),
-    taxes: import_zod53.z.string(),
-    total: import_zod53.z.string()
+    save: import_zod54.z.string(),
+    shipping: import_zod54.z.string(),
+    subtotal: import_zod54.z.string(),
+    taxes: import_zod54.z.string(),
+    total: import_zod54.z.string()
   }),
   product: OfferProduct.pick({ description: true, id: true, image: true, title: true }).extend({
     description: OfferProduct.shape.description.nullable(),
     id: PostPurchaseProductId,
     variant: PostPurchaseVariant
   }),
-  selection: import_zod53.z.object({
+  selection: import_zod54.z.object({
     productId: PostPurchaseProductId,
-    quantity: import_zod53.z.number().int().positive(),
-    sellingPlanId: import_zod53.z.number().int().positive().optional(),
+    quantity: import_zod54.z.number().int().positive(),
+    sellingPlanId: import_zod54.z.number().int().positive().optional(),
     variantId: PostPurchaseVariantId
   }),
-  status: import_zod53.z.literal("prepared"),
-  terms: import_zod53.z.object({
+  status: import_zod54.z.literal("prepared"),
+  terms: import_zod54.z.object({
     discount: PostPurchaseDiscount,
-    shipping: import_zod53.z.object({
-      amount: import_zod53.z.number().nonnegative(),
-      title: import_zod53.z.string(),
-      type: import_zod53.z.enum(["free", "fixed_amount"])
+    shipping: import_zod54.z.object({
+      amount: import_zod54.z.number().nonnegative(),
+      title: import_zod54.z.string(),
+      type: import_zod54.z.enum(["free", "fixed_amount"])
     }),
     subscription: PostPurchaseSubscriptionTerms.optional()
   })
 });
-var PostPurchasePreparation = import_zod53.z.discriminatedUnion("status", [
+var PostPurchasePreparation = import_zod54.z.discriminatedUnion("status", [
   PreparedPostPurchaseProduct,
-  import_zod53.z.object({ reason: import_zod53.z.string(), status: import_zod53.z.literal("unsupported") })
+  import_zod54.z.object({ reason: import_zod54.z.string(), status: import_zod54.z.literal("unsupported") })
 ]);
 
 // src/schema/postPurchaseSubscriptionProduct.ts
 var PreparedPostPurchaseSubscription = PreparedPostPurchaseProduct.extend({
-  selection: PreparedPostPurchaseProduct.shape.selection.extend({ sellingPlanId: import_zod54.z.number().int().positive() }),
+  selection: PreparedPostPurchaseProduct.shape.selection.extend({ sellingPlanId: import_zod55.z.number().int().positive() }),
   terms: PreparedPostPurchaseProduct.shape.terms.extend({
     subscription: PostPurchaseSubscriptionTerms
   }).refine(
@@ -6101,7 +6136,7 @@ var subscriptionUnavailable = (normalized, plan, allowCollection, quantity2) =>
 };
 
 // src/server/postPurchaseProductDisplay.ts
-var import_zod55 = require("zod");
+var import_zod57 = require("zod");
 
 // src/server/postPurchasePrimaryImage.ts
 var postPurchasePrimaryImage = (product) => {
@@ -6122,9 +6157,67 @@ var postPurchaseProductGallery = (product, limit) => ({
   selectedImageId: product.images?.find((image) => image.id === product.variants[0].imageId)?.id
 });
 
+// src/transforms/postPurchase/convertDescriptionRte.ts
+var import_zod56 = require("zod");
+var alignments = { center: "center", left: "start", right: "end" };
+var colors = ["critical", "subdued", "success", "warning"];
+var sizes2 = ["extraSmall", "small", "medium", "large", "extraLarge"];
+var spacings2 = {
+  default: "base",
+  loose: "loose",
+  none: "none",
+  tight: "tight",
+  xloose: "extraLoose",
+  xtight: "extraTight"
+};
+var Block = import_zod56.z.object({
+  attrs: import_zod56.z.object({ alignment: import_zod56.z.enum(["left", "center", "right"]).optional().catch(void 0) }).catch({}),
+  content: import_zod56.z.array(import_zod56.z.unknown()).catch([]),
+  type: import_zod56.z.literal("ShopifyTextBlock")
+});
+var Run = import_zod56.z.object({ marks: import_zod56.z.array(import_zod56.z.unknown()).catch([]), text: import_zod56.z.string().min(1), type: import_zod56.z.literal("text") });
+var Inline = import_zod56.z.object({
+  attrs: import_zod56.z.object({
+    color: import_zod56.z.enum(colors).optional().catch(void 0),
+    emphasis: import_zod56.z.array(import_zod56.z.unknown()).catch([]),
+    size: import_zod56.z.enum(sizes2).optional().catch(void 0)
+  }),
+  type: import_zod56.z.literal("ShopifyTextInline")
+});
+var marks = (raw) => {
+  const found = raw.map((mark) => Inline.safeParse(mark)).find(({ success }) => success)?.data;
+  if (!found) return [];
+  const { color = "base", emphasis, size = "base" } = found.attrs;
+  return [
+    ...emphasis.includes("bold") ? [{ type: "bold" }] : [],
+    ...emphasis.includes("strikethrough") ? [{ type: "strike" }] : [],
+    { attrs: { color, fontSize: size }, type: "textStyle" }
+  ];
+};
+var convertDescriptionRte = (rte, spacing) => TiptapDocument.parse({
+  attrs: { blockSpacing: spacings2[spacing ?? "none"] },
+  content: rte.content.flatMap((node) => {
+    const block = Block.safeParse(node);
+    if (!block.success) return [];
+    const { alignment } = block.data.attrs;
+    return [
+      {
+        attrs: { textAlign: alignment ? alignments[alignment] : "start" },
+        content: block.data.content.flatMap((inline) => {
+          const run = Run.safeParse(inline);
+          return run.success ? [{ marks: marks(run.data.marks), text: run.data.text }] : [];
+        }),
+        type: "paragraph"
+      }
+    ];
+  }),
+  type: "doc"
+});
+
 // src/server/postPurchaseProductDisplay.ts
-var ResponseLanguage = import_zod55.z.object({ description: PostPurchaseProductDisplay.shape.responseDescription }).default({ description: "" });
+var ResponseLanguage = import_zod57.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,
   gallery: postPurchaseProductGallery(product, effective.subImages),
   language: effective.language,
@@ -6134,12 +6227,142 @@ var projectPostPurchaseProductDisplay = (effective, metadata, product) => PostPu
   shouldShowSavingText: effective.discount.shouldShowSavingText
 });
 
+// src/server/postPurchaseReviewData.ts
+var import_zod61 = require("zod");
+
+// src/server/postPurchaseJudgeMeReviews.ts
+var import_zod58 = require("zod");
+var readJudgeMeReviews = (find) => {
+  const field = find("judgeme", "badge");
+  if (!field) return null;
+  const html = import_zod58.z.string().parse(field.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");
+  return {
+    rating: PostPurchaseCommonReviewRating.parse({ value: rating[1] }).value,
+    reviewCount: PostPurchaseReviewCount.parse(count[1])
+  };
+};
+
+// src/server/postPurchaseOkendoReviews.ts
+var import_zod59 = require("zod");
+var Summary = import_zod59.z.object({
+  reviewAverageValue: PostPurchaseCommonReviewRating.shape.value,
+  reviewCount: import_zod59.z.union([PostPurchaseProductReviews.shape.reviewCount, PostPurchaseReviewCount])
+});
+var readOkendoReviews = (find) => {
+  const field = find("okendo", "summaryData");
+  if (!field) return null;
+  const summary = Summary.parse(JSON.parse(import_zod59.z.string().parse(field.value)));
+  return { rating: summary.reviewAverageValue, reviewCount: summary.reviewCount };
+};
+
+// src/server/postPurchaseScalarReviews.ts
+var import_zod60 = require("zod");
+var readScalarReviews = (find, namespace, ratingKey, countKey) => {
+  const rating = find(namespace, ratingKey);
+  const count = find(namespace, countKey);
+  if (!rating || !count) return null;
+  return {
+    rating: PostPurchaseCommonReviewRating.parse({ value: import_zod60.z.string().parse(rating.value) }).value,
+    reviewCount: PostPurchaseReviewCount.parse(count.value)
+  };
+};
+
+// src/server/postPurchaseReviewData.ts
+var readPostPurchaseReviewData = (provider, find) => {
+  if (provider === "yotpo") return readScalarReviews(find, "yotpo", "reviews_average", "reviews_count");
+  if (provider === "stamped") return readScalarReviews(find, "stamped", "reviews_average", "reviews_count");
+  if (provider === "judgeme") return readJudgeMeReviews(find);
+  if (provider === "okendo") return readOkendoReviews(find);
+  if (provider === "opinew") return readScalarReviews(find, "opinew_metafields", "reviews_average", "reviews_count");
+  if (provider === "reviewsio") return readScalarReviews(find, "reviewscouk", "rating", "total");
+  if (provider === "loox") return readScalarReviews(find, "loox", "avg_rating", "num_reviews");
+  if (provider === "junip") return readScalarReviews(find, "junip", "rating_average", "rating_count");
+  const rating = find("reviews", "rating");
+  const count = find("reviews", "rating_count");
+  if (!rating || !count) return null;
+  return {
+    rating: PostPurchaseKlaviyoReviewRating.parse(JSON.parse(import_zod61.z.string().parse(rating.value))).value,
+    reviewCount: PostPurchaseReviewCount.parse(count.value)
+  };
+};
+
+// src/server/postPurchaseReviewFields.ts
+var import_zod62 = require("zod");
+var Field = import_zod62.z.object({ key: import_zod62.z.string(), namespace: import_zod62.z.string(), value: import_zod62.z.unknown().optional() });
+var reviewFields = (raw) => {
+  const fields4 = import_zod62.z.array(import_zod62.z.unknown()).parse(raw).flatMap((field) => {
+    const parsed = Field.safeParse(field);
+    return parsed.success ? [parsed.data] : [];
+  });
+  return (namespace, key) => fields4.find((field) => field.namespace === namespace && field.key === key);
+};
+
+// src/server/postPurchaseReviewProvider.ts
+var import_zod63 = require("zod");
+var IntegrationInput = import_zod63.z.record(import_zod63.z.string(), import_zod63.z.unknown()).prefault({});
+var precedence = [
+  "klaviyo",
+  "judgeme",
+  "junip",
+  "loox",
+  "okendo",
+  "opinew",
+  "reviewsio",
+  "stamped",
+  "yotpo"
+];
+var ReviewsIoFlag = import_zod63.z.preprocess((value) => {
+  if (typeof value === "string") {
+    const flag = value.toLowerCase();
+    if (flag === "true" || flag === "yes") return true;
+    if (flag === "false" || flag === "no") return false;
+  }
+  return value;
+}, PostPurchaseSettings.shape.integrations.shape.reviewsio);
+var selectPostPurchaseReviewProvider = (raw) => {
+  const integrations = IntegrationInput.parse(raw);
+  for (const provider of precedence) {
+    const schema = provider === "reviewsio" ? ReviewsIoFlag : PostPurchaseSettings.shape.integrations.shape[provider];
+    if (schema.parse(integrations[provider])) return provider;
+  }
+  return null;
+};
+
+// src/server/postPurchaseReviews.ts
+var projectPostPurchaseReviews = (settings, metafields, report) => {
+  try {
+    const provider = selectPostPurchaseReviewProvider(settings.integrations);
+    if (!provider || metafields == null) return null;
+    const data = readPostPurchaseReviewData(provider, reviewFields(metafields));
+    if (data === null || data.rating === 0) return null;
+    const styles2 = PostPurchaseReviewStyles.parse(settings.styles);
+    return PostPurchaseProductReviews.parse({
+      color: styles2.starColor,
+      ...data,
+      reviewsPlural: settings.language.global.reviewsPlural,
+      reviewsSingular: settings.language.global.reviewsSingular,
+      size: styles2.starSize,
+      strokeColor: styles2.starStrokeColor,
+      strokeWidth: styles2.strokeWidth
+    });
+  } catch {
+    report?.({ detail: "Unreadable post-purchase reviews", kind: "product" });
+    return null;
+  }
+};
+
 // src/server/projectPostPurchaseProduct.ts
-var projectPostPurchaseProduct = ({ data, effective, metadata, original }, selectedQuantity) => {
+var projectPostPurchaseProduct = ({ data, effective, metadata, original }, report, selectedQuantity) => {
   const product = data[0];
   const variant2 = product.variants[0];
   return {
-    display: projectPostPurchaseProductDisplay(effective, metadata, product),
+    display: {
+      ...projectPostPurchaseProductDisplay(effective, metadata, product),
+      reviews: projectPostPurchaseReviews(effective, product.metafields, report)
+    },
     labels: effective.language.global,
     product: { ...product, variant: variant2 },
     selection: {
@@ -6156,7 +6379,7 @@ var prepareNormalizedSubscription = (normalized, report, plan, quantity2, allowC
   const reason = subscriptionUnavailable(normalized, plan, allowCollection, quantity2);
   if (reason) return { reason, status: "unsupported" };
   const { effective } = normalized;
-  const projected = projectPostPurchaseProduct(normalized, quantity2);
+  const projected = projectPostPurchaseProduct(normalized, report, quantity2);
   const { discount, shipping } = PostPurchaseSubscriptionSettings.parse(effective.subscription);
   const shippingPrice = shipping.type === "free" ? 0 : shipping.amount;
   return PreparedPostPurchaseSubscription.parse({
@@ -6193,72 +6416,262 @@ var preparePostPurchaseSubscription = (settings, response, report) => {
   );
 };
 
-// src/schema/postPurchaseOfferEligibility.ts
-var import_zod57 = require("zod");
+// src/server/postPurchaseProductEligibility.ts
+var oneTimeUnavailable = (normalized, allowCollection, quantity2) => {
+  const { data, effective, original } = normalized;
+  if (data.length !== 1 || data[0].variants.length !== 1) return "Only one fixed product and variant are supported";
+  if (effective.productType === "subscription" || [original, effective].some(
+    (config) => !allowCollection && config.productLimit !== 1 || config.upgradeToSubscription.allow || !quantity2 && config.quantityInputs.enabled && (config.quantityInputs.minValue !== config.quantityInputs.maxValue || config.quantityInputs.defaultQuantity !== config.quantityInputs.minValue)
+  ))
+    return "Only fixed one-time configuration is supported";
+  const product = data[0];
+  const variant2 = product.variants[0];
+  if (product.productGroupVariants.length || product.sellingPlanGroups?.some((group) => group.requiresSellingPlan) || !postPurchaseVariantAvailable(variant2))
+    return "An available one-time variant without product groups is required";
+  if (variant2.productId !== product.id) throw new Error("Product variant identity mismatch");
+};
 
-// src/schema/postPurchaseProductCollectionView.ts
-var import_zod56 = require("zod");
-var PostPurchaseExcludedProductIds = import_zod56.z.array(PostPurchaseProductId).default([]);
+// src/server/preparePostPurchaseProduct.ts
+var prepareNormalizedProduct = (normalized, report, quantity2, allowCollection = false) => {
+  const reason = oneTimeUnavailable(normalized, allowCollection, quantity2);
+  if (reason) return { reason, status: "unsupported" };
+  const { effective } = normalized;
+  return PreparedPostPurchaseProduct.parse({
+    ...projectPostPurchaseProduct(normalized, report, quantity2),
+    status: "prepared",
+    terms: {
+      discount: { ...effective.discount, title: effective.language.global.save },
+      shipping: effective.shipping
+    }
+  });
+};
+var preparePostPurchaseProduct = (settings, response, report) => prepareNormalizedProduct(normalizePostPurchaseProduct(settings, response), report);
 
-// src/schema/postPurchaseOfferEligibility.ts
-var selection = PreparedPostPurchaseProduct.shape.selection;
-var PostPurchaseOfferSkipReason = import_zod57.z.enum(["empty", "no-eligible-subscription"]);
-var PostPurchaseOfferEligibilityContext = import_zod57.z.object({
-  excludedProductIds: PostPurchaseExcludedProductIds,
-  originalLineItems: import_zod57.z.array(selection.pick({ productId: true, sellingPlanId: true, variantId: true }))
-});
-var PostPurchaseOfferEligibility = import_zod57.z.discriminatedUnion("status", [
-  import_zod57.z.object({
-    members: import_zod57.z.array(
-      import_zod57.z.object({ productId: selection.shape.productId, productIndex: import_zod57.z.number().int().nonnegative() })
-    ),
-    status: import_zod57.z.literal("retain")
-  }),
-  import_zod57.z.object({ reason: PostPurchaseOfferSkipReason, status: import_zod57.z.literal("skip") }),
-  import_zod57.z.object({ reason: import_zod57.z.literal("eligible-upgrade").optional(), status: import_zod57.z.literal("unavailable") })
+// src/schema/postPurchaseProductView.ts
+var import_zod67 = require("zod");
+
+// src/schema/postPurchaseChoice.ts
+var import_zod64 = require("zod");
+var PostPurchaseChoice = import_zod64.z.discriminatedUnion("mode", [
+  import_zod64.z.object({ mode: import_zod64.z.literal("one-time") }).strict(),
+  import_zod64.z.object({ mode: import_zod64.z.literal("subscription"), sellingPlanId: PostPurchasePlanOption.shape.id }).strict()
 ]);
+var PostPurchaseOptions = import_zod64.z.object({
+  defaultChoice: PostPurchaseChoice,
+  modes: import_zod64.z.array(import_zod64.z.enum(["one-time", "subscription"])).min(1).max(2),
+  selector: PostPurchaseSettings.shape.productTypeSelector
+});
 
-// src/server/normalizePostPurchaseCollection.ts
-var import_zod58 = require("zod");
-var normalizePostPurchaseCollection = (settings, response, excludedProductIds) => {
-  const normalized = normalizePostPurchaseProduct(settings, response);
-  const limit = import_zod58.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)
-    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));
-  return { members, normalized };
-};
+// src/schema/postPurchaseGroupCatalog.ts
+var import_zod66 = require("zod");
 
 // src/schema/postPurchaseVariantCatalog.ts
-var import_zod59 = require("zod");
-var PostPurchaseVariantSelector = import_zod59.z.object({ variantId: PostPurchaseVariantId }).strict();
+var import_zod65 = require("zod");
+var PostPurchaseVariantSelector = import_zod65.z.object({ variantId: PostPurchaseVariantId }).strict();
 var PostPurchaseVariantOption = OfferProduct.shape.options.element.extend({
-  id: import_zod59.z.number().int().positive(),
-  position: import_zod59.z.number().int().min(1).max(3)
+  id: import_zod65.z.number().int().positive(),
+  position: import_zod65.z.number().int().min(1).max(3)
 });
 var PostPurchaseVariantValues = OfferProduct.shape.variants.element.pick({
   option1: true,
   option2: true,
   option3: true
 });
-var PostPurchaseVariantCatalog = import_zod59.z.object({
+var PostPurchaseVariantCatalog = import_zod65.z.object({
   displayMode: PostPurchaseSettings.shape.productOptions.shape.variantSelectorDisplayMode,
-  options: import_zod59.z.array(PostPurchaseVariantOption),
+  options: import_zod65.z.array(PostPurchaseVariantOption),
   productId: PostPurchaseProductId,
   showSelectors: PostPurchaseSettings.shape.productOptions.shape.showVariantSelectors,
-  variants: import_zod59.z.array(
+  variants: import_zod65.z.array(
     PostPurchaseVariantValues.partial().extend({
-      available: import_zod59.z.boolean(),
+      available: import_zod65.z.boolean(),
       id: PostPurchaseVariantId,
-      imageId: import_zod59.z.number().int().nonnegative().nullish(),
+      imageId: import_zod65.z.number().int().nonnegative().nullish(),
       title: OfferProduct.shape.variants.element.shape.title
     })
   )
 });
 
+// src/schema/postPurchaseGroupCatalog.ts
+var productId = PreparedPostPurchaseProduct.shape.selection.shape.productId;
+var source = PostPurchaseProductSource.shape.data.element;
+var PostPurchaseGroupDescription = source.pick({ description: true, id: true, image: true, images: true, title: true }).extend({
+  description: source.shape.description.default(null),
+  image: source.shape.image.default(null),
+  options: PostPurchaseVariantCatalog.shape.options.default([])
+});
+var PostPurchaseGroupCatalog = import_zod66.z.object({
+  memberProductId: productId,
+  options: import_zod66.z.array(import_zod66.z.object({ productId, title: import_zod66.z.string(), variantCatalog: PostPurchaseVariantCatalog }))
+});
+var PostPurchaseGroupSelection = import_zod66.z.object({
+  memberProductId: productId,
+  productId
+});
+
+// src/schema/postPurchaseProductView.ts
+var PostPurchaseProductView = import_zod67.z.union([
+  import_zod67.z.object({
+    groupCatalog: PostPurchaseGroupCatalog.optional(),
+    initialVariant: PostPurchaseVariantSelector.optional(),
+    planCatalog: PostPurchasePlanCatalog.nullable().optional(),
+    preparation: PreparedPostPurchaseProduct.extend({
+      display: PreparedPostPurchaseProduct.shape.display.extend({ description: import_zod67.z.string().nullable() }).refine(
+        ({ description, descriptionDocument }) => description === null === (descriptionDocument !== void 0),
+        "Exactly one of the plain and rich descriptions is shown"
+      )
+    }),
+    purchaseOptions: PostPurchaseOptions.optional(),
+    sections: CABRootSection,
+    variantCatalog: PostPurchaseVariantCatalog.optional()
+  }),
+  import_zod67.z.object({
+    groupCatalog: PostPurchaseGroupCatalog.optional(),
+    initialVariant: PostPurchaseVariantSelector.optional(),
+    planCatalog: PostPurchasePlanCatalog.nullable().optional(),
+    preparation: PostPurchasePreparation.options[1],
+    purchaseOptions: PostPurchaseOptions.optional(),
+    sections: import_zod67.z.null(),
+    variantCatalog: PostPurchaseVariantCatalog.optional()
+  })
+]);
+
+// src/server/postPurchaseOfferCopy.ts
+var import_zod68 = require("zod");
+var Copy = import_zod68.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_zod68.z.object({ settings: import_zod68.z.record(import_zod68.z.string(), import_zod68.z.unknown()), type: import_zod68.z.literal("callout_banner") });
+var postPurchaseOfferCopy = (blocks, metadata) => {
+  const copy = Copy.safeParse(metadata.widget.language);
+  if (!blocks || !copy.success) return blocks;
+  const first = blocks.findIndex((block) => Callout.pick({ type: true }).safeParse(block).success);
+  return blocks.map((block, index) => {
+    if (index !== first) return block;
+    const callout = Callout.passthrough().safeParse(block);
+    if (!callout.success) return block;
+    return {
+      ...callout.data,
+      settings: {
+        ...callout.data.settings,
+        ...copy.data.title && { title: copy.data.title },
+        ...copy.data.superTitle && { superTitle: copy.data.superTitle }
+      }
+    };
+  });
+};
+
+// src/server/selectPostPurchaseChoice.ts
+var selectPostPurchaseChoice = (normalized, projected, requested, allowCollection, quantity2) => {
+  const { data, effective } = normalized;
+  const modes = [];
+  const catalog = projected && projected.productId === data[0]?.id && projected.variantId === data[0].variants[0]?.id ? projected : null;
+  const firstPlan = catalog?.plans[0];
+  const oneTimeReason = oneTimeUnavailable(normalized, allowCollection, quantity2);
+  const subscriptionReason = subscriptionUnavailable(normalized, firstPlan, allowCollection, quantity2);
+  if (!oneTimeReason) modes.push("one-time");
+  if (!subscriptionReason) modes.push("subscription");
+  if (oneTimeReason && subscriptionReason)
+    return {
+      choice: void 0,
+      options: void 0,
+      plan: void 0,
+      reason: effective.productType === "one-time" ? oneTimeReason : subscriptionReason
+    };
+  const defaultChoice = firstPlan && modes.includes("subscription") && (modes[0] === "subscription" || effective.subscriptionIsDefault) ? { mode: "subscription", sellingPlanId: firstPlan.id } : { mode: "one-time" };
+  const options2 = PostPurchaseOptions.parse({ defaultChoice, modes, selector: effective.productTypeSelector });
+  const choice = requested ?? defaultChoice;
+  const plan = choice.mode === "subscription" ? catalog?.plans.find(({ id }) => id === choice.sellingPlanId) : void 0;
+  const bound = modes.includes(choice.mode) && (choice.mode === "one-time" || plan) ? choice : void 0;
+  return {
+    choice: bound,
+    options: options2,
+    plan: bound ? plan : void 0,
+    reason: bound ? void 0 : "Requested purchase choice is unavailable"
+  };
+};
+
+// src/server/preparePostPurchaseView.ts
+var resolveDescription = ({ descriptionDocument, ...display }, productDescription) => {
+  const plain = display.language.descriptionEnabled && productDescription || display.responseDescription || (descriptionDocument ? null : display.language.description);
+  return plain === null ? { ...display, description: null, descriptionDocument } : { ...display, description: plain };
+};
+var prepareNormalizedPostPurchaseView = (widgetId, normalized, report, choice, quantity2, allowCollection = false) => {
+  const planCatalog = projectPostPurchasePlanCatalog(normalized, report);
+  const selected = selectPostPurchaseChoice(normalized, planCatalog, choice, allowCollection, quantity2);
+  const purchaseOptions = selected.options;
+  const preparation = !selected.choice ? { reason: selected.reason, status: "unsupported" } : selected.choice.mode === "subscription" ? prepareNormalizedSubscription(normalized, report, selected.plan, quantity2, allowCollection) : prepareNormalizedProduct(normalized, report, quantity2, allowCollection);
+  const unsupported = (reason) => ({
+    planCatalog,
+    preparation: { reason, status: "unsupported" },
+    purchaseOptions,
+    sections: null
+  });
+  if (preparation.status === "unsupported") return { planCatalog, preparation, purchaseOptions, sections: null };
+  if (!normalized.effective.blocks?.length) return unsupported("One fixed product information block is required");
+  const sections = convertMessagePreview(
+    widgetId,
+    {
+      blocks: postPurchaseOfferCopy(normalized.effective.blocks, normalized.metadata),
+      type: "shopify_post_purchase_extension"
+    },
+    report
+  );
+  if (sections.sections.filter((section) => section.sectionType === "offers").length !== 1)
+    return unsupported("One fixed product information block is required");
+  return PostPurchaseProductView.parse({
+    planCatalog,
+    preparation: {
+      ...preparation,
+      display: resolveDescription(preparation.display, preparation.product.description)
+    },
+    purchaseOptions,
+    sections
+  });
+};
+var preparePostPurchaseView = (widgetId, settings, response, report, choice) => prepareNormalizedPostPurchaseView(widgetId, normalizePostPurchaseProduct(settings, response), report, choice);
+
+// src/server/preparePostPurchaseAdmissionView.ts
+var preparePostPurchaseAdmissionView = (widgetId, settings, response, report, choice) => {
+  const normalized = normalizePostPurchaseProduct(settings, response);
+  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_zod69 = require("zod");
+var PostPurchaseProductCollectionView = import_zod69.z.object({
+  members: import_zod69.z.array(
+    import_zod69.z.object({
+      productId: PostPurchaseProductId,
+      productIndex: import_zod69.z.number().int().nonnegative(),
+      view: PostPurchaseProductView
+    })
+  )
+});
+var PostPurchaseCollectionChoice = import_zod69.z.object({
+  choice: PostPurchaseChoice.optional(),
+  productId: PostPurchaseProductId,
+  variantId: PostPurchaseVariantSelector.shape.variantId.optional()
+}).strict();
+var PostPurchaseExcludedProductIds = import_zod69.z.array(PostPurchaseProductId).default([]);
+
+// src/server/normalizePostPurchaseCollection.ts
+var import_zod70 = require("zod");
+var normalizePostPurchaseCollection = (settings, response, excludedProductIds) => {
+  const normalized = normalizePostPurchaseProduct(settings, response);
+  const limit = import_zod70.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)
+    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));
+  return { members, normalized };
+};
+
 // src/server/postPurchaseVariantCatalog.ts
 var projectPostPurchaseVariantCatalog = (product, settings) => {
   const options2 = PostPurchaseVariantCatalog.shape.options.parse(product.options === void 0 ? [] : product.options).sort((a, b) => a.position - b.position);
@@ -6292,22 +6705,216 @@ var projectPostPurchaseVariantCatalog = (product, settings) => {
   });
 };
 
-// src/schema/postPurchaseGroupCatalog.ts
-var import_zod60 = require("zod");
-var productId = PreparedPostPurchaseProduct.shape.selection.shape.productId;
-var source = PostPurchaseProductSource.shape.data.element;
-var PostPurchaseGroupDescription = source.pick({ description: true, id: true, image: true, images: true, title: true }).extend({
-  description: source.shape.description.default(null),
-  image: source.shape.image.default(null),
-  options: PostPurchaseVariantCatalog.shape.options.default([])
+// src/schema/postPurchaseQuantity.ts
+var import_zod71 = require("zod");
+var quantity = PreparedPostPurchaseProduct.shape.selection.shape.quantity;
+var PostPurchaseQuantityChoice = PostPurchaseCollectionChoice.extend({ quantity: quantity.optional() });
+var PostPurchaseQuantityPolicy = PostPurchaseSettings.shape.quantityInputs.omit({ defaultQuantity: true }).extend({
+  initialQuantity: quantity,
+  maxValue: quantity,
+  minValue: import_zod71.z.literal(0).transform(() => 1).or(quantity)
+}).refine(({ maxValue, minValue }) => minValue <= maxValue, "Quantity bounds are reversed");
+
+// src/server/readPostPurchaseQuantity.ts
+var PostPurchaseQuantityUnavailable = class extends Error {
+};
+var readPostPurchaseQuantity = ({
+  data,
+  effective,
+  original
+}, selection3) => {
+  const positive = PreparedPostPurchaseProduct.shape.selection.shape.quantity;
+  for (const config of [original, effective]) {
+    if (!config.quantityInputs.enabled) continue;
+    const initialQuantity2 = positive.parse(config.quantityInputs.defaultQuantity);
+    const policy2 = PostPurchaseQuantityPolicy.parse({ ...config.quantityInputs, initialQuantity: initialQuantity2 });
+    if (initialQuantity2 < policy2.minValue || initialQuantity2 > policy2.maxValue)
+      throw new Error("Configured quantity default is outside its bounds");
+  }
+  const initialQuantity = data[0]?.metadata?.productQuantity ?? (original.quantityInputs.enabled ? original.quantityInputs.defaultQuantity : 1);
+  const policy = PostPurchaseQuantityPolicy.parse(
+    effective.quantityInputs.enabled ? { ...effective.quantityInputs, initialQuantity } : { enabled: false, initialQuantity, maxValue: initialQuantity, minValue: initialQuantity }
+  );
+  const requested = "quantity" in selection3 ? selection3.quantity : selection3.expectedQuantity === initialQuantity ? void 0 : selection3.expectedQuantity;
+  const quantity2 = positive.parse(requested ?? initialQuantity);
+  if (requested !== void 0 && (policy.enabled ? quantity2 < policy.minValue || quantity2 > policy.maxValue : quantity2 !== initialQuantity))
+    throw new PostPurchaseQuantityUnavailable("Requested quantity is unavailable");
+  return { policy, quantity: quantity2 };
+};
+
+// src/schema/postPurchaseVariantDefault.ts
+var import_zod72 = require("zod");
+var values = PostPurchaseVariantValues.partial().extend({
+  option1: PostPurchaseVariantValues.shape.option1.nullish()
 });
-var PostPurchaseGroupCatalog = import_zod60.z.object({
-  memberProductId: productId,
-  options: import_zod60.z.array(import_zod60.z.object({ productId, title: import_zod60.z.string(), variantCatalog: PostPurchaseVariantCatalog }))
+var variant = values.extend({
+  id: PostPurchaseVariantId,
+  inventoryManagement: import_zod72.z.string().nullable(),
+  inventoryPolicy: import_zod72.z.string(),
+  inventoryQuantity: import_zod72.z.number()
 });
-var PostPurchaseGroupSelection = import_zod60.z.object({
-  memberProductId: productId,
-  productId
+var options = import_zod72.z.array(PostPurchaseVariantOption.pick({ name: true, values: true }));
+var PostPurchaseVariantDefaultProduct = import_zod72.z.object({
+  id: PostPurchaseProductId,
+  options,
+  selectedVariant: variant.optional(),
+  variants: import_zod72.z.array(variant)
+});
+var PostPurchaseVariantDefaultSettings = PostPurchaseSettings.shape.productOptions.pick({
+  hideOutOfStockVariants: true,
+  matchVariant: true
+});
+var PostPurchaseOrderAttributes = import_zod72.z.record(import_zod72.z.string(), import_zod72.z.array(import_zod72.z.string())).default({});
+var PostPurchaseOriginalVariants = import_zod72.z.array(
+  import_zod72.z.object({ productId: PostPurchaseProductId, variantId: PostPurchaseVariantId })
+);
+var PostPurchaseAttributeProducts = import_zod72.z.array(
+  import_zod72.z.object({ id: PostPurchaseProductId, options, variants: import_zod72.z.array(values.extend({ id: PostPurchaseVariantId })) })
+);
+
+// src/schema/postPurchaseVariantDefaultContext.ts
+var import_zod73 = require("zod");
+var PostPurchaseVariantDefaultContext = import_zod73.z.object({
+  enrichedLineItems: import_zod73.z.unknown().optional(),
+  originalVariants: PostPurchaseOriginalVariants
+});
+
+// src/server/createPostPurchaseOrderAttributes.ts
+var createPostPurchaseOrderAttributes = (original, enriched) => {
+  const products = PostPurchaseAttributeProducts.parse(enriched);
+  const attributes = {};
+  for (const item of PostPurchaseOriginalVariants.parse(original)) {
+    const product = products.find(({ id }) => id === item.productId);
+    const variant2 = product?.variants.find(({ id }) => id === item.variantId);
+    if (!variant2 || !product) continue;
+    ["option1", "option2", "option3"].forEach((key, index) => {
+      const value = variant2[key];
+      const option = product.options[index];
+      if (!value || !option) return;
+      const values2 = attributes[option.name] ?? [];
+      if (!values2.includes(value)) attributes[option.name] = [...values2, value];
+    });
+  }
+  return attributes;
+};
+
+// src/server/matchPostPurchaseVariantDefault.ts
+var matchPostPurchaseVariantDefault = (product, attributes, filterOutOfStock) => {
+  const keys = ["option1", "option2", "option3"];
+  const values2 = keys.map((_, index) => {
+    const option = product.options[index];
+    return option ? option.values.filter((value) => attributes[option.name]?.includes(value)) : [];
+  });
+  if (!values2.some((entries) => entries.length)) return;
+  let bestRank = 1;
+  let best;
+  for (const variant2 of product.variants) {
+    if (filterOutOfStock && variant2.inventoryPolicy !== "continue" && variant2.inventoryQuantity <= 0) continue;
+    const rank = keys.reduce((total, key, index) => {
+      const value = variant2[key];
+      return total + Number(!value && !values2[index].length || !!value && values2[index].includes(value));
+    }, 0);
+    if (rank > bestRank) {
+      best = variant2;
+      bestRank = rank;
+    }
+  }
+  return best;
+};
+
+// src/server/resolvePostPurchaseVariantDefault.ts
+var resolvePostPurchaseVariantDefault = (source2, settings, originalAttributes) => {
+  const product = PostPurchaseVariantDefaultProduct.parse(source2);
+  const policy = PostPurchaseVariantDefaultSettings.parse(settings);
+  const attributes = PostPurchaseOrderAttributes.parse(originalAttributes);
+  let selected = source2.selectedVariant && source2.selectedVariant === source2.variants[0] ? product.variants[0] : product.selectedVariant;
+  if (!selected && policy.matchVariant)
+    selected = matchPostPurchaseVariantDefault(product, attributes, policy.hideOutOfStockVariants);
+  selected ?? (selected = product.variants[0]);
+  if (!selected || selected === product.variants[0])
+    selected = product.variants.find(postPurchaseVariantAvailable) ?? selected;
+  return selected?.id ?? null;
+};
+
+// src/server/resolvePostPurchaseMemberDefault.ts
+var resolvePostPurchaseMemberDefault = (product, original, context) => {
+  const originals = PostPurchaseVariantDefaultContext.parse(context);
+  if (product.variants.length < 2 && product.selectedVariant === void 0) return product.variants[0]?.id ?? null;
+  const source2 = PostPurchaseVariantDefaultProduct.parse(product);
+  const settings = PostPurchaseVariantDefaultSettings.parse(original.productOptions);
+  const attributes = settings.matchVariant && !source2.selectedVariant && source2.options.some(({ values: values2 }) => values2.length > 0) && originals.originalVariants.length > 0 && originals.enrichedLineItems != null ? createPostPurchaseOrderAttributes(
+    originals.originalVariants,
+    PostPurchaseAttributeProducts.parse(deepCamelCase(originals.enrichedLineItems))
+  ) : void 0;
+  return resolvePostPurchaseVariantDefault(source2, settings, attributes);
+};
+
+// src/server/preparePostPurchaseMemberView.ts
+var prepareMember = (widgetId, settings, response, requested, report, excludedProductIds, requestedQuantity, defaults) => {
+  const selected = PostPurchaseCollectionChoice.parse(requested);
+  const { members, normalized } = normalizePostPurchaseCollection(settings, response, excludedProductIds);
+  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));
+  const product = variantId === void 0 ? found.product : {
+    ...found.product,
+    variants: found.product.variants.filter(({ id }) => id === variantId)
+  };
+  const selectedInput = { ...normalized, data: [product] };
+  const quantity2 = requestedQuantity ? readPostPurchaseQuantity(selectedInput, requestedQuantity) : void 0;
+  const view = prepareNormalizedPostPurchaseView(widgetId, selectedInput, report, selected.choice, quantity2, true);
+  if (selected.variantId !== void 0 || found.product.variants.length > 1)
+    view.variantCatalog = projectPostPurchaseVariantCatalog(found.product, normalized.effective);
+  if (defaults && selected.variantId === void 0 && variantId && view.variantCatalog?.variants.some(({ id }) => id === variantId))
+    view.initialVariant = { variantId };
+  return { member: { productId: found.product.id, productIndex: found.productIndex, view }, normalized, quantity: quantity2 };
+};
+var preparePostPurchaseMemberView = (widgetId, settings, response, requested, report, excludedProductIds) => prepareMember(widgetId, settings, response, requested, report, excludedProductIds)?.member ?? null;
+var preparePostPurchaseMemberAdmissionView = (widgetId, settings, response, requested, report, excludedProductIds) => {
+  const prepared = prepareMember(widgetId, settings, response, requested, report, excludedProductIds);
+  if (!prepared) return null;
+  const { removePartialOrder } = PostPurchaseSettings.shape.advance.parse(prepared.normalized.effective.advance);
+  return { ...prepared.member, removePartialOrder };
+};
+
+// src/server/preparePostPurchaseQuantityView.ts
+var preparePostPurchaseQuantityView = (widgetId, settings, response, requested, report, excludedProductIds, defaults) => {
+  const { quantity: quantity2, ...selection3 } = PostPurchaseQuantityChoice.parse(requested);
+  const prepared = prepareMember(
+    widgetId,
+    settings,
+    response,
+    selection3,
+    report,
+    excludedProductIds,
+    { quantity: quantity2 },
+    defaults
+  );
+  return prepared ? { ...prepared.member, quantityPolicy: prepared.quantity.policy } : null;
+};
+
+// src/server/preparePostPurchaseQuantityAdmissionView.ts
+var selection = PostPurchaseQuantityChoice.required({ quantity: true });
+var preparePostPurchaseQuantityAdmissionView = (widgetId, settings, response, expected, report, excludedProductIds, defaults) => {
+  const { quantity: expectedQuantity, ...requested } = selection.parse(expected);
+  const prepared = prepareMember(
+    widgetId,
+    settings,
+    response,
+    requested,
+    report,
+    excludedProductIds,
+    { expectedQuantity },
+    defaults
+  );
+  if (!prepared) return null;
+  const { removePartialOrder } = PostPurchaseSettings.shape.advance.parse(prepared.normalized.effective.advance);
+  return { ...prepared.member, quantityPolicy: prepared.quantity.policy, removePartialOrder };
+};
+
+// src/schema/postPurchaseGroup.ts
+var PostPurchaseGroupChoice = PostPurchaseQuantityChoice.extend({
+  memberProductId: PreparedPostPurchaseProduct.shape.selection.shape.productId
 });
 
 // src/server/readPostPurchaseGroup.ts
@@ -6340,6 +6947,195 @@ var readPostPurchaseGroup = (product, settings, excludedProductIds) => {
   };
 };
 
+// src/server/readPostPurchaseGroupSelection.ts
+var readPostPurchaseGroupSelection = (settings, response, requested, excludedProductIds) => {
+  const selection3 = PostPurchaseGroupSelection.parse(requested);
+  const { members, normalized } = normalizePostPurchaseCollection(settings, response);
+  const member = members.find(({ product }) => product.id === selection3.memberProductId);
+  if (!member || !member.product.productGroupVariants.length) return null;
+  const group = readPostPurchaseGroup(member.product, normalized.effective, excludedProductIds);
+  const entry = group.entries.find(({ product }) => product.id === selection3.productId);
+  if (!entry) return null;
+  return {
+    groupCatalog: group.catalog,
+    memberProductId: member.product.id,
+    productIndex: member.productIndex,
+    reportingProduct: { id: member.product.id, title: member.product.title },
+    response: { data: [entry.product], metadata: normalized.metadata },
+    variantCatalog: entry.variantCatalog
+  };
+};
+
+// src/server/preparePostPurchaseGroupView.ts
+var preparePostPurchaseGroupView = (widgetId, settings, response, requested, report, excludedProductIds) => {
+  const { memberProductId, ...selection3 } = PostPurchaseGroupChoice.parse(requested);
+  const group = readPostPurchaseGroupSelection(settings, response, requested, excludedProductIds);
+  if (!group) return null;
+  const variantId = selection3.variantId ?? group.variantCatalog.variants.find(({ available }) => available)?.id;
+  if (variantId === void 0) return null;
+  const prepared = preparePostPurchaseQuantityView(
+    widgetId,
+    settings,
+    group.response,
+    { ...selection3, variantId },
+    report
+  );
+  return prepared && {
+    ...prepared,
+    groupCatalog: group.groupCatalog,
+    memberProductId,
+    productIndex: group.productIndex,
+    reportingProduct: group.reportingProduct
+  };
+};
+
+// src/server/preparePostPurchaseGroupAdmissionView.ts
+var preparePostPurchaseGroupAdmissionView = (widgetId, settings, response, requested, report, excludedProductIds) => {
+  const { memberProductId, ...selection3 } = PostPurchaseGroupChoice.required({ quantity: true }).parse(requested);
+  const group = readPostPurchaseGroupSelection(settings, response, requested, excludedProductIds);
+  if (!group) return null;
+  const variantId = selection3.variantId ?? group.variantCatalog.variants.find(({ available }) => available)?.id;
+  if (variantId === void 0) return null;
+  const prepared = preparePostPurchaseQuantityAdmissionView(
+    widgetId,
+    settings,
+    group.response,
+    { ...selection3, variantId },
+    report
+  );
+  return prepared && {
+    ...prepared,
+    groupCatalog: group.groupCatalog,
+    memberProductId,
+    productIndex: group.productIndex,
+    reportingProduct: group.reportingProduct
+  };
+};
+
+// src/server/preparePostPurchaseGroupDefault.ts
+var preparePostPurchaseGroupDefault = (widgetId, settings, response, memberProductId, context, report, excludedProductIds) => {
+  const { members, normalized } = normalizePostPurchaseCollection(settings, response);
+  const member = members.find(({ product }) => product.id === memberProductId);
+  if (!member || !member.product.productGroupVariants.length) return null;
+  const group = readPostPurchaseGroup(member.product, normalized.effective, excludedProductIds);
+  const ids = new Set(group.entries.map(({ product }) => product.id));
+  const variants = member.product.variants.filter(({ productId: productId2 }) => ids.has(productId2));
+  const selected = PostPurchaseVariantDefaultProduct.shape.selectedVariant.parse(member.product.selectedVariant);
+  const selectedOwner = selected && member.product.variants.find(({ id }) => id === selected.id);
+  const variantId = resolvePostPurchaseMemberDefault(
+    {
+      ...member.product,
+      selectedVariant: selectedOwner && !ids.has(selectedOwner.productId) ? void 0 : member.product.selectedVariant,
+      variants
+    },
+    normalized.original,
+    context
+  );
+  const entry = group.entries.find(({ product }) => product.variants.some(({ id }) => id === variantId));
+  if (!entry || variantId === null) return null;
+  const prepared = preparePostPurchaseGroupView(
+    widgetId,
+    settings,
+    response,
+    { memberProductId, productId: entry.product.id, variantId },
+    report,
+    excludedProductIds
+  );
+  return prepared && { ...prepared, view: { ...prepared.view, initialVariant: { variantId } } };
+};
+
+// src/server/preparePostPurchaseCollectionGroup.ts
+var preparePostPurchaseCollectionGroup = (widgetId, settings, response, member, normalized, excluded, defaults, report) => {
+  const group = readPostPurchaseGroup(member.product, normalized.effective, excluded);
+  if (!group.entries.length) return null;
+  const prepared = preparePostPurchaseGroupDefault(
+    widgetId,
+    settings,
+    response,
+    member.product.id,
+    defaults,
+    report,
+    excluded
+  );
+  return {
+    productId: member.product.id,
+    productIndex: member.productIndex,
+    reportingProduct: { id: member.product.id, title: member.product.title },
+    view: prepared ? { ...prepared.view, groupCatalog: prepared.groupCatalog } : {
+      groupCatalog: group.catalog,
+      preparation: { reason: "Post-purchase group default is unavailable", status: "unsupported" },
+      sections: null
+    }
+  };
+};
+
+// src/server/preparePostPurchaseCollectionView.ts
+var CollectionChoice = PostPurchaseCollectionChoice.omit({ variantId: true });
+var preparePostPurchaseCollectionView = (widgetId, settings, response, report, requested, excludedProductIds, defaults = { originalVariants: [] }) => {
+  const { members, normalized } = normalizePostPurchaseCollection(settings, response);
+  const excluded = PostPurchaseExcludedProductIds.parse(excludedProductIds);
+  const selected = CollectionChoice.optional().parse(requested);
+  const projected = members.map((member) => {
+    if (member.product.productGroupVariants.length) {
+      if (selected?.productId === member.product.id && selected.choice)
+        throw new Error("Grouped choices require selected merchandise");
+      const group = preparePostPurchaseCollectionGroup(
+        widgetId,
+        settings,
+        response,
+        member,
+        normalized,
+        excluded,
+        defaults,
+        report
+      );
+      return group;
+    }
+    if (excluded.includes(member.product.id)) return null;
+    return {
+      productId: member.product.id,
+      productIndex: member.productIndex,
+      reportingProduct: void 0,
+      view: prepareNormalizedPostPurchaseView(
+        widgetId,
+        { ...normalized, data: [member.product] },
+        report,
+        member.product.id === selected?.productId ? selected.choice : void 0,
+        void 0,
+        true
+      )
+    };
+  }).filter((member) => member !== null);
+  if (selected && !projected.some(({ productId: productId2 }) => productId2 === selected.productId))
+    throw new Error("Requested product is outside the prepared collection");
+  const collection = PostPurchaseProductCollectionView.parse({ members: projected });
+  return {
+    members: collection.members.map((member, index) => ({
+      ...member,
+      ...projected[index].reportingProduct && { reportingProduct: projected[index].reportingProduct }
+    }))
+  };
+};
+
+// src/schema/postPurchaseOfferEligibility.ts
+var import_zod74 = require("zod");
+var selection2 = PreparedPostPurchaseProduct.shape.selection;
+var PostPurchaseOfferSkipReason = import_zod74.z.enum(["empty", "no-eligible-subscription"]);
+var PostPurchaseOfferEligibilityContext = import_zod74.z.object({
+  excludedProductIds: PostPurchaseExcludedProductIds,
+  originalLineItems: import_zod74.z.array(selection2.pick({ productId: true, sellingPlanId: true, variantId: true }))
+});
+var PostPurchaseOfferEligibility = import_zod74.z.discriminatedUnion("status", [
+  import_zod74.z.object({
+    members: import_zod74.z.array(
+      import_zod74.z.object({ productId: selection2.shape.productId, productIndex: import_zod74.z.number().int().nonnegative() })
+    ),
+    status: import_zod74.z.literal("retain")
+  }),
+  import_zod74.z.object({ reason: PostPurchaseOfferSkipReason, status: import_zod74.z.literal("skip") }),
+  import_zod74.z.object({ reason: import_zod74.z.literal("eligible-upgrade").optional(), status: import_zod74.z.literal("unavailable") })
+]);
+
 // src/server/postPurchaseMemberEligibility.ts
 var PostPurchaseInventoryUnavailable = class extends Error {
 };
@@ -6415,74 +7211,6 @@ var classifyPostPurchaseOffer = (settings, response, context) => {
   }
 };
 
-// src/schema/postPurchaseVariantDefault.ts
-var import_zod61 = require("zod");
-var values = PostPurchaseVariantValues.partial().extend({
-  option1: PostPurchaseVariantValues.shape.option1.nullish()
-});
-var variant = values.extend({
-  id: PostPurchaseVariantId,
-  inventoryManagement: import_zod61.z.string().nullable(),
-  inventoryPolicy: import_zod61.z.string(),
-  inventoryQuantity: import_zod61.z.number()
-});
-var options = import_zod61.z.array(PostPurchaseVariantOption.pick({ name: true, values: true }));
-var PostPurchaseVariantDefaultProduct = import_zod61.z.object({
-  id: PostPurchaseProductId,
-  options,
-  selectedVariant: variant.optional(),
-  variants: import_zod61.z.array(variant)
-});
-var PostPurchaseVariantDefaultSettings = PostPurchaseSettings.shape.productOptions.pick({
-  hideOutOfStockVariants: true,
-  matchVariant: true
-});
-var PostPurchaseOrderAttributes = import_zod61.z.record(import_zod61.z.string(), import_zod61.z.array(import_zod61.z.string())).default({});
-var PostPurchaseOriginalVariants = import_zod61.z.array(
-  import_zod61.z.object({ productId: PostPurchaseProductId, variantId: PostPurchaseVariantId })
-);
-var PostPurchaseAttributeProducts = import_zod61.z.array(
-  import_zod61.z.object({ id: PostPurchaseProductId, options, variants: import_zod61.z.array(values.extend({ id: PostPurchaseVariantId })) })
-);
-
-// src/server/createPostPurchaseOrderAttributes.ts
-var createPostPurchaseOrderAttributes = (original, enriched) => {
-  const products = PostPurchaseAttributeProducts.parse(enriched);
-  const attributes = {};
-  for (const item of PostPurchaseOriginalVariants.parse(original)) {
-    const product = products.find(({ id }) => id === item.productId);
-    const variant2 = product?.variants.find(({ id }) => id === item.variantId);
-    if (!variant2 || !product) continue;
-    ["option1", "option2", "option3"].forEach((key, index) => {
-      const value = variant2[key];
-      const option = product.options[index];
-      if (!value || !option) return;
-      const values2 = attributes[option.name] ?? [];
-      if (!values2.includes(value)) attributes[option.name] = [...values2, value];
-    });
-  }
-  return attributes;
-};
-
-// src/server/readPostPurchaseGroupSelection.ts
-var readPostPurchaseGroupSelection = (settings, response, requested, excludedProductIds) => {
-  const selection2 = PostPurchaseGroupSelection.parse(requested);
-  const { members, normalized } = normalizePostPurchaseCollection(settings, response);
-  const member = members.find(({ product }) => product.id === selection2.memberProductId);
-  if (!member || !member.product.productGroupVariants.length) return null;
-  const group = readPostPurchaseGroup(member.product, normalized.effective, excludedProductIds);
-  const entry = group.entries.find(({ product }) => product.id === selection2.productId);
-  if (!entry) return null;
-  return {
-    groupCatalog: group.catalog,
-    memberProductId: member.product.id,
-    productIndex: member.productIndex,
-    reportingProduct: { id: member.product.id, title: member.product.title },
-    response: { data: [entry.product], metadata: normalized.metadata },
-    variantCatalog: entry.variantCatalog
-  };
-};
-
 // src/server/preparePostPurchaseGroupDeclineDisplay.ts
 var preparePostPurchaseGroupDeclineDisplay = (settings, response, requested, excludedProductIds) => {
   const group = readPostPurchaseGroupSelection(settings, response, requested, excludedProductIds);
@@ -6499,47 +7227,21 @@ var preparePostPurchaseGroupDeclineDisplay = (settings, response, requested, exc
 
 // src/server/preparePostPurchaseOfferPresentation.ts
 var import_compat7 = require("es-toolkit/compat");
-var import_zod64 = require("zod");
+var import_zod76 = require("zod");
 
 // src/schema/postPurchaseOfferPresentation.ts
-var import_zod62 = require("zod");
+var import_zod75 = require("zod");
 var language2 = PostPurchaseSettings.shape.language.shape.global.unwrap().unwrap();
-var PostPurchaseOfferPresentation = import_zod62.z.strictObject({
+var PostPurchaseOfferPresentation = import_zod75.z.strictObject({
   labels: language2.pick({ declineAll: true, declineThisOffer: true }),
   layout: PostPurchaseSettings.shape.offersLayout,
   sections: CABRootSection.nullable(),
   showDeclineAll: PostPurchaseSettings.shape.productOptions.shape.showDeclineAll
 });
 
-// src/server/postPurchaseOfferCopy.ts
-var import_zod63 = require("zod");
-var Copy = import_zod63.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_zod63.z.object({ settings: import_zod63.z.record(import_zod63.z.string(), import_zod63.z.unknown()), type: import_zod63.z.literal("callout_banner") });
-var postPurchaseOfferCopy = (blocks, metadata) => {
-  const copy = Copy.safeParse(metadata.widget.language);
-  if (!blocks || !copy.success) return blocks;
-  const first = blocks.findIndex((block) => Callout.pick({ type: true }).safeParse(block).success);
-  return blocks.map((block, index) => {
-    if (index !== first) return block;
-    const callout = Callout.passthrough().safeParse(block);
-    if (!callout.success) return block;
-    return {
-      ...callout.data,
-      settings: {
-        ...callout.data.settings,
-        ...copy.data.title && { title: copy.data.title },
-        ...copy.data.superTitle && { superTitle: copy.data.superTitle }
-      }
-    };
-  });
-};
-
 // src/server/preparePostPurchaseOfferPresentation.ts
 var FrameSettings = PostPurchaseSettings.pick({ language: true, offersLayout: true, productOptions: true }).extend({
-  blocks: import_zod64.z.array(import_zod64.z.unknown()).optional()
+  blocks: import_zod76.z.array(import_zod76.z.unknown()).optional()
 });
 var preparePostPurchaseOfferPresentation = (widgetId, settings, response, report) => {
   const { metadata } = PostPurchaseProductSource.pick({ metadata: true }).parse(deepCamelCase(response));
@@ -6563,42 +7265,6 @@ var preparePostPurchaseOfferPresentation = (widgetId, settings, response, report
   });
 };
 
-// src/schema/postPurchaseQuantity.ts
-var import_zod65 = require("zod");
-var quantity = PreparedPostPurchaseProduct.shape.selection.shape.quantity;
-var PostPurchaseQuantityPolicy = PostPurchaseSettings.shape.quantityInputs.omit({ defaultQuantity: true }).extend({
-  initialQuantity: quantity,
-  maxValue: quantity,
-  minValue: import_zod65.z.literal(0).transform(() => 1).or(quantity)
-}).refine(({ maxValue, minValue }) => minValue <= maxValue, "Quantity bounds are reversed");
-
-// src/server/readPostPurchaseQuantity.ts
-var PostPurchaseQuantityUnavailable = class extends Error {
-};
-var readPostPurchaseQuantity = ({
-  data,
-  effective,
-  original
-}, selection2) => {
-  const positive = PreparedPostPurchaseProduct.shape.selection.shape.quantity;
-  for (const config of [original, effective]) {
-    if (!config.quantityInputs.enabled) continue;
-    const initialQuantity2 = positive.parse(config.quantityInputs.defaultQuantity);
-    const policy2 = PostPurchaseQuantityPolicy.parse({ ...config.quantityInputs, initialQuantity: initialQuantity2 });
-    if (initialQuantity2 < policy2.minValue || initialQuantity2 > policy2.maxValue)
-      throw new Error("Configured quantity default is outside its bounds");
-  }
-  const initialQuantity = data[0]?.metadata?.productQuantity ?? (original.quantityInputs.enabled ? original.quantityInputs.defaultQuantity : 1);
-  const policy = PostPurchaseQuantityPolicy.parse(
-    effective.quantityInputs.enabled ? { ...effective.quantityInputs, initialQuantity } : { enabled: false, initialQuantity, maxValue: initialQuantity, minValue: initialQuantity }
-  );
-  const requested = "quantity" in selection2 ? selection2.quantity : selection2.expectedQuantity === initialQuantity ? void 0 : selection2.expectedQuantity;
-  const quantity2 = positive.parse(requested ?? initialQuantity);
-  if (requested !== void 0 && (policy.enabled ? quantity2 < policy.minValue || quantity2 > policy.maxValue : quantity2 !== initialQuantity))
-    throw new PostPurchaseQuantityUnavailable("Requested quantity is unavailable");
-  return { policy, quantity: quantity2 };
-};
-
 // src/server/analytics.ts
 var import_es_toolkit7 = require("es-toolkit");
 
@@ -6735,7 +7401,7 @@ var postAnalyticsEvents = async (input, ctx) => {
 };
 
 // src/server/requestSchemas.ts
-var import_zod66 = require("zod");
+var import_zod77 = require("zod");
 var REQUEST_BOUNDS = {
   /** Cart-level attributes per cart. */
   CART_ATTRIBUTES_MAX: 100,
@@ -6766,42 +7432,42 @@ var REQUEST_BOUNDS = {
   /** Rich ads transaction lines — the engine's ads contract. */
   TRANSACTION_ITEMS_MAX: 50
 };
-var KeyValue = import_zod66.z.object({
-  key: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX),
-  value: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_VALUE_MAX).optional()
+var KeyValue = import_zod77.z.object({
+  key: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX),
+  value: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_VALUE_MAX).optional()
 });
-var CartLineInputSchema = import_zod66.z.object({
-  productId: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
-  properties: import_zod66.z.array(KeyValue).max(REQUEST_BOUNDS.LINE_PROPERTIES_MAX).optional(),
-  quantity: import_zod66.z.number(),
-  subscriptionId: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  variantId: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX)
+var CartLineInputSchema = import_zod77.z.object({
+  productId: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  properties: import_zod77.z.array(KeyValue).max(REQUEST_BOUNDS.LINE_PROPERTIES_MAX).optional(),
+  quantity: import_zod77.z.number(),
+  subscriptionId: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  variantId: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX)
 });
-var CartInputSchema = import_zod66.z.object({
-  attributes: import_zod66.z.array(KeyValue).max(REQUEST_BOUNDS.CART_ATTRIBUTES_MAX).optional(),
+var CartInputSchema = import_zod77.z.object({
+  attributes: import_zod77.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_zod66.z.number().optional(),
+  currencyRate: import_zod77.z.number().optional(),
   /** Applied discount codes; the engine evaluates `discount_code` rules against them (sent as `[{code}]`). */
-  discountCodes: import_zod66.z.array(import_zod66.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX)).max(REQUEST_BOUNDS.DISCOUNT_CODES_MAX).optional(),
+  discountCodes: import_zod77.z.array(import_zod77.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_zod66.z.number().optional(),
-  items: import_zod66.z.array(CartLineInputSchema).max(REQUEST_BOUNDS.CART_ITEMS_MAX),
+  discountTotal: import_zod77.z.number().optional(),
+  items: import_zod77.z.array(CartLineInputSchema).max(REQUEST_BOUNDS.CART_ITEMS_MAX),
   /** Presentment subtotal in cents. */
-  subtotal: import_zod66.z.number()
+  subtotal: import_zod77.z.number()
 });
-var UserConfigInputSchema = import_zod66.z.object({ shop: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX) });
-var DataSourceInputSchema = import_zod66.z.object({
+var UserConfigInputSchema = import_zod77.z.object({ shop: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX) });
+var DataSourceInputSchema = import_zod77.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_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  companyLocationId: import_zod77.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
@@ -6810,16 +7476,16 @@ var DataSourceInputSchema = import_zod66.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_zod66.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_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  dataSourcePath: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX),
+  country: import_zod77.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_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  dataSourcePath: import_zod77.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_zod66.z.enum(["no", "yes"]).optional(),
-  integrations: import_zod66.z.record(import_zod66.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX), import_zod66.z.boolean()).refine((record) => Object.keys(record).length <= REQUEST_BOUNDS.INTEGRATION_KEYS_MAX, {
+  filterInputs: import_zod77.z.enum(["no", "yes"]).optional(),
+  integrations: import_zod77.z.record(import_zod77.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX), import_zod77.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(),
   /**
@@ -6832,31 +7498,31 @@ var DataSourceInputSchema = import_zod66.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_zod66.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_zod66.z.number().max(REQUEST_BOUNDS.LIMIT_MAX),
-  productType: import_zod66.z.enum(["both", "one-time", "subscription"]).optional(),
-  shop: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
-  visitorId: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
-});
-var GiftInputSchema = import_zod66.z.object({
-  cost: import_zod66.z.number(),
-  discounted: import_zod66.z.boolean(),
+  language: import_zod77.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_zod77.z.number().max(REQUEST_BOUNDS.LIMIT_MAX),
+  productType: import_zod77.z.enum(["both", "one-time", "subscription"]).optional(),
+  shop: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  visitorId: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
+});
+var GiftInputSchema = import_zod77.z.object({
+  cost: import_zod77.z.number(),
+  discounted: import_zod77.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_zod66.z.enum(GIFT_KINDS).default("gwp"),
-  lineId: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
-  productId: import_zod66.z.number(),
+  kind: import_zod77.z.enum(GIFT_KINDS).default("gwp"),
+  lineId: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  productId: import_zod77.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_zod66.z.number().int().min(1).default(1),
-  widgetId: import_zod66.z.number()
+  quantity: import_zod77.z.number().int().min(1).default(1),
+  widgetId: import_zod77.z.number()
 });
-var GiftValidationInputSchema = import_zod66.z.object({
+var GiftValidationInputSchema = import_zod77.z.object({
   cart: CartInputSchema,
   /**
    * Buyer's market country — threaded into the per-widget data-source evaluations, which forward it to
@@ -6865,25 +7531,25 @@ var GiftValidationInputSchema = import_zod66.z.object({
    * turns markets off); regex-bound and uppercase-normalized for the same reasons as
    * `DataSourceInputSchema`'s `country`.
    */
-  country: import_zod66.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_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  gifts: import_zod66.z.array(GiftInputSchema).max(REQUEST_BOUNDS.GIFTS_MAX),
+  country: import_zod77.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_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  gifts: import_zod77.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_zod66.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_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
-  visitorId: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
+  language: import_zod77.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_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  visitorId: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
 });
-var GiftAdjustmentSchema = import_zod66.z.object({
-  lineId: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
-  quantity: import_zod66.z.number().int().nonnegative()
+var GiftAdjustmentSchema = import_zod77.z.object({
+  lineId: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  quantity: import_zod77.z.number().int().nonnegative()
 });
-var GiftValidationResponseSchema = import_zod66.z.object({
-  adjust: import_zod66.z.array(GiftAdjustmentSchema).max(REQUEST_BOUNDS.GIFTS_MAX).default([]),
-  remove: import_zod66.z.array(import_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX)).max(REQUEST_BOUNDS.GIFTS_MAX).refine(
+var GiftValidationResponseSchema = import_zod77.z.object({
+  adjust: import_zod77.z.array(GiftAdjustmentSchema).max(REQUEST_BOUNDS.GIFTS_MAX).default([]),
+  remove: import_zod77.z.array(import_zod77.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`"
   )
@@ -6894,47 +7560,47 @@ var GiftValidationResponseSchema = import_zod66.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_zod66.z.object({
-  id: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
-  priceCents: import_zod66.z.number(),
-  quantity: import_zod66.z.number(),
-  title: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX),
-  type: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX)
-});
-var MonetizeInputSchema = import_zod66.z.object({
+var MonetizeTransactionItemSchema = import_zod77.z.object({
+  id: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  priceCents: import_zod77.z.number(),
+  quantity: import_zod77.z.number(),
+  title: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX),
+  type: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX)
+});
+var MonetizeInputSchema = import_zod77.z.object({
   cart: CartInputSchema,
   /** Client-minted render-beacon correlation id; forwarded to the ads engine as `client_request_id`. */
-  clientRequestId: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  country: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  currency: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  clientRequestId: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  country: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  currency: import_zod77.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_zod66.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
-  customerFirstName: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
-  customerId: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  customerLastName: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
-  language: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  customerEmail: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
+  customerFirstName: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
+  customerId: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  customerLastName: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
+  language: import_zod77.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_zod66.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
+  orderName: import_zod77.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_zod66.z.enum(["customer_account", "order_status", "thank_you_page"]),
+  placement: import_zod77.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_zod66.z.string().max(REQUEST_BOUNDS.STRING_URL_MAX).optional(),
+  privacyPolicyUrl: import_zod77.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_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  shop: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  sessionId: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  shop: import_zod77.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_zod66.z.boolean().optional(),
-  timezone: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  testing: import_zod77.z.boolean().optional(),
+  timezone: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
   /** Decorated (numeric) order id → the ads `transaction_id`. */
-  transactionId: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  transactionId: import_zod77.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_zod66.z.array(MonetizeTransactionItemSchema).max(REQUEST_BOUNDS.TRANSACTION_ITEMS_MAX).optional(),
+  transactionItems: import_zod77.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_zod66.z.number().optional(),
-  visitorId: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  zipCode: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
+  transactionTotal: import_zod77.z.number().optional(),
+  visitorId: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  zipCode: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
 });
-var WidgetSettingsInputSchema = import_zod66.z.object({
+var WidgetSettingsInputSchema = import_zod77.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
@@ -6942,9 +7608,9 @@ var WidgetSettingsInputSchema = import_zod66.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_zod66.z.number().int().positive().optional().catch(void 0),
-  id: import_zod66.z.number(),
-  key: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  cacheKey: import_zod77.z.number().int().positive().optional().catch(void 0),
+  id: import_zod77.z.number(),
+  key: import_zod77.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`
@@ -6953,34 +7619,34 @@ var WidgetSettingsInputSchema = import_zod66.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_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  shop: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
   /** Stable per-buyer id; when present, enables sticky server-side A/B variant selection. */
-  visitorId: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
+  visitorId: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
 });
-var AnalyticsEventInputSchema = import_zod66.z.object({
-  name: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX),
-  properties: import_zod66.z.record(import_zod66.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX), import_zod66.z.unknown()).optional(),
-  sentAt: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
+var AnalyticsEventInputSchema = import_zod77.z.object({
+  name: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX),
+  properties: import_zod77.z.record(import_zod77.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX), import_zod77.z.unknown()).optional(),
+  sentAt: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
 });
-var AnalyticsSegmentsInputSchema = import_zod66.z.object({
-  device: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional().catch(void 0),
-  source: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional().catch(void 0),
-  visitor: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional().catch(void 0)
+var AnalyticsSegmentsInputSchema = import_zod77.z.object({
+  device: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional().catch(void 0),
+  source: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional().catch(void 0),
+  visitor: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional().catch(void 0)
 });
-var AnalyticsInputSchema = import_zod66.z.object({
+var AnalyticsInputSchema = import_zod77.z.object({
   /** Rebuy cart token (the `r_cart_token` cart attribute), when available — primary aggregation key. */
-  cartToken: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  cartToken: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
   /** Shopify checkout token, when available — drives cart/checkout aggregation downstream. */
-  checkoutToken: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  events: import_zod66.z.array(AnalyticsEventInputSchema).max(REQUEST_BOUNDS.EVENTS_MAX),
+  checkoutToken: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  events: import_zod77.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_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
-  visitorId: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  shop: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  visitorId: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
   /** The widget id (smartBlockId) the events belong to. */
-  widgetId: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
+  widgetId: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
 });