@rebuy/rebuy 3.34.0 → 3.36.0

package/dist/server/index.cjs

@@ -33,18 +33,36 @@ __export(server_exports, {
   MonetizeInputSchema: () => MonetizeInputSchema,
   MonetizeTransactionItemSchema: () => MonetizeTransactionItemSchema,
   NotFoundError: () => NotFoundError,
+  PostPurchaseQuantityUnavailable: () => PostPurchaseQuantityUnavailable,
   REBUY_ENGINE_HOST: () => REBUY_ENGINE_HOST,
   REQUEST_BOUNDS: () => REQUEST_BOUNDS,
   UpstreamError: () => UpstreamError,
   UserConfigInputSchema: () => UserConfigInputSchema,
   WidgetSettingsInputSchema: () => WidgetSettingsInputSchema,
   buildEngineParams: () => buildEngineParams,
+  classifyPostPurchaseOffer: () => classifyPostPurchaseOffer,
   convertWidgetSettings: () => convertWidgetSettings,
+  createPostPurchaseOrderAttributes: () => createPostPurchaseOrderAttributes,
   fetchDataSourceResults: () => fetchDataSourceResults,
   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,
   validateGifts: () => validateGifts
 });
@@ -679,7 +697,7 @@ var import_uuid13 = require("uuid");
 var import_zod27 = require("zod");
 
 // src/schema/widgets/checkout-and-beyond/common.ts
-var freezeEnum = (values) => Object.freeze(Object.fromEntries(values.map((v) => [v, v])));
+var freezeEnum = (values2) => Object.freeze(Object.fromEntries(values2.map((v) => [v, v])));
 var bannerColors = ["info", "success", "warning", "critical"];
 var BannerColor = freezeEnum(bannerColors);
 var borderRadii = ["none", "small", "base", "large", "fullyRounded"];
@@ -2145,15 +2163,15 @@ var CABImageSectionFields = import_zod27.z.object({
   width: import_zod27.z.number().default(100)
 });
 var iconNameSet = new Set(iconNames);
-var isIconName = (source) => iconNameSet.has(source);
-var CABImageSection = CABImageSectionFields.superRefine(({ category, source }, ctx) => {
-  if (category === "icon" && source !== "" && !isIconName(source))
+var isIconName = (source2) => iconNameSet.has(source2);
+var CABImageSection = CABImageSectionFields.superRefine(({ category, source: source2 }, ctx) => {
+  if (category === "icon" && source2 !== "" && !isIconName(source2))
     ctx.addIssue({
       code: "custom",
       message: "icon-mode source must be an icon name",
       path: ["source"]
     });
-  if (category !== "icon" && isIconName(source))
+  if (category !== "icon" && isIconName(source2))
     ctx.addIssue({
       code: "custom",
       message: "source must be a URL or dynamic token unless category is `icon`",
@@ -2171,7 +2189,7 @@ var stripContentBlockHtml = (text2) => text2.replace(HTML_COMMENT_RE, "").replac
 var convertTextToTiptapParagraph = ({
   color,
   fontSize,
-  marks = [],
+  marks: marks2 = [],
   text: text2,
   textAlign
 }) => {
@@ -2180,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"
       }
@@ -2265,10 +2283,10 @@ var HEADER_PARAGRAPH_STYLES = {
   superTitle: { color: "base", fontSize: "extraLarge", marks: [{ type: "bold" }] },
   title: { color: "base", fontSize: "medium", marks: [{ type: "bold" }] }
 };
-var convertContentBlockTextToV2 = (language2, text2 = literalText, textAlign = "center") => {
-  const description = language2?.description;
-  const superTitle = language2?.superTitle;
-  const title = language2?.title;
+var convertContentBlockTextToV2 = (language3, text2 = literalText, textAlign = "center") => {
+  const description = language3?.description;
+  const superTitle = language3?.superTitle;
+  const title = language3?.title;
   return TiptapDocument.parse({
     attrs: { blockSpacing: "tight" },
     content: [
@@ -2380,7 +2398,7 @@ var LOCATION_TO_EDITOR_MODE = {
 };
 
 // src/transforms/contentBlockV1/convertContentBlockToV2.ts
-var hasText = (language2) => !!language2 && !!(language2.description || language2.superTitle || language2.title);
+var hasText = (language3) => !!language3 && !!(language3.description || language3.superTitle || language3.title);
 var convertContentBlockToV2 = ({ id, settings }) => {
   const imageBlocks = settings.imageBlocks ?? [];
   return CABRootSection.parse({
@@ -2637,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 }));
   });
 };
 
@@ -2653,15 +2671,15 @@ var stripHtmlComments = (html = "") => html.replace(HTML_COMMENT_RE2, "");
 var maybeFlushParagraph = (state) => {
   if (state.currentRuns.length > 0) flushParagraph(state);
 };
-var htmlToTiptap = (html, options = {}) => {
+var htmlToTiptap = (html, options2 = {}) => {
   const state = {
     currentRuns: [],
-    defaultTextStyleMark: buildDefaultTextStyleMark(options.defaultTextStyle),
+    defaultTextStyleMark: buildDefaultTextStyleMark(options2.defaultTextStyle),
     listStack: [],
     paragraphs: [],
     stack: []
   };
-  const blockSpacing = options.blockSpacing ?? "base";
+  const blockSpacing = options2.blockSpacing ?? "base";
   if (typeof html !== "string" || !html) return makeDoc([makeParagraph([])], blockSpacing);
   const htmlWithoutComments = stripHtmlComments(html);
   let lastIndex = 0;
@@ -2906,9 +2924,9 @@ var isMonetizeV1 = isWidgetV1(WidgetType.ui_extension_ad);
 var HTML_TAG_RE2 = /<[a-zA-Z]/;
 var containsHtml = (text2) => HTML_TAG_RE2.test(text2);
 var isObject = (x) => x !== null && typeof x === "object" && !Array.isArray(x);
-var normalizeTextValue = (value, options = {}) => {
+var normalizeTextValue = (value, options2 = {}) => {
   const tokenized = normalizeTokens(value);
-  return containsHtml(tokenized) || options.defaultTextStyle ? htmlToTiptap(tokenized, options) : decodeTextEntities(tokenized);
+  return containsHtml(tokenized) || options2.defaultTextStyle ? htmlToTiptap(tokenized, options2) : decodeTextEntities(tokenized);
 };
 var normalizeLangValue = (value) => typeof value === "string" ? normalizeTextValue(value) : value;
 var normalizeTextContent = (node) => {
@@ -2941,15 +2959,15 @@ var resolveExperiment = (experiments, placeholderId, visitorId) => {
   if (!experiment || experiment.data.length === 0) return void 0;
   const roll = rollPercent(`${visitorId}:${experiment.id}`);
   let cumulative = 0;
-  const variant = experiment.data.find((candidate) => {
+  const variant2 = experiment.data.find((candidate) => {
     cumulative += candidate.traffic;
     return roll < cumulative;
   }) ?? experiment.data[0];
   return {
-    elementId: variant.elementId,
+    elementId: variant2.elementId,
     experimentId: experiment.id,
     experimentType: experiment.type,
-    selectedId: variant.id
+    selectedId: variant2.id
   };
 };
 
@@ -3216,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: [
@@ -3397,23 +3415,23 @@ var QUANTITY_INPUT_TYPE = {
   "buttons-manual-input": "number",
   "dropdown-select": "select"
 };
-var buildQuantityErrors = (quantity) => {
+var buildQuantityErrors = (quantity2) => {
   const en = {
-    ...quantity.maxError && { max: normalizeTokens(quantity.maxError, QUANTITY_ERROR_TOKENS) },
-    ...quantity.minError && { min: normalizeTokens(quantity.minError, QUANTITY_ERROR_TOKENS) },
-    ...quantity.negativeError && { neg: normalizeTokens(quantity.negativeError, QUANTITY_ERROR_TOKENS) }
+    ...quantity2.maxError && { max: normalizeTokens(quantity2.maxError, QUANTITY_ERROR_TOKENS) },
+    ...quantity2.minError && { min: normalizeTokens(quantity2.minError, QUANTITY_ERROR_TOKENS) },
+    ...quantity2.negativeError && { neg: normalizeTokens(quantity2.negativeError, QUANTITY_ERROR_TOKENS) }
   };
   return Object.keys(en).length ? { errorMessages: { en } } : {};
 };
 var buildQuantity = (settings) => {
-  const quantity = settings.quantityInputs;
-  if (!quantity?.enabled) return [];
-  const inputType = quantity.type ? QUANTITY_INPUT_TYPE[quantity.type] : void 0;
-  const max = Math.min(Math.max(quantity.maxValue ?? 10, 1), 100);
-  const min = Math.min(Math.max(quantity.minValue ?? 1, 1), max);
+  const quantity2 = settings.quantityInputs;
+  if (!quantity2?.enabled) return [];
+  const inputType = quantity2.type ? QUANTITY_INPUT_TYPE[quantity2.type] : void 0;
+  const max = Math.min(Math.max(quantity2.maxValue ?? 10, 1), 100);
+  const min = Math.min(Math.max(quantity2.minValue ?? 1, 1), max);
   return [
     {
-      ...buildQuantityErrors(quantity),
+      ...buildQuantityErrors(quantity2),
       ...inputType && { inputType },
       max,
       min,
@@ -3423,7 +3441,7 @@ var buildQuantity = (settings) => {
 };
 var buildSubscriptionButton = (settings) => {
   if (settings.productType !== "both" && settings.productType !== "subscription") return [];
-  const language2 = settings.language;
+  const language3 = settings.language;
   const slot = (buttonField, override) => ({
     buttonField,
     content: localizedContent(SWITCH_LABELS[buttonField], override, SWITCH_LABEL_TOKENS2),
@@ -3437,9 +3455,9 @@ var buildSubscriptionButton = (settings) => {
       ...settings.productType === "subscription" && { disableDowngrade: true },
       sections: [
         slot("subscriptionOption", void 0),
-        slot("switchToOneTimePurchase", language2?.cartSwitchToOnetime),
-        slot("switchToSubscriptionNoDiscount", language2?.upgradeToSubscription),
-        slot("switchToSubscriptionWithDiscount", language2?.upgradeToSubscription)
+        slot("switchToOneTimePurchase", language3?.cartSwitchToOnetime),
+        slot("switchToSubscriptionNoDiscount", language3?.upgradeToSubscription),
+        slot("switchToSubscriptionWithDiscount", language3?.upgradeToSubscription)
       ],
       sectionType: "button"
     }
@@ -3494,11 +3512,11 @@ var buildOfferCard = (settings, horizontal) => {
   const description = buildDescription(settings);
   const reviews = buildReviews(settings);
   const variants = buildVariants(settings);
-  const quantity = buildQuantity(settings);
+  const quantity2 = buildQuantity(settings);
   const subscription2 = buildSubscriptionButton(settings);
   const reveal = buildRevealButton(settings);
   const addButton = buildAddButton(settings);
-  const controls = [...description, ...quantity, ...variants, ...subscription2];
+  const controls = [...description, ...quantity2, ...variants, ...subscription2];
   const info = detailBlock([title, ...variantTitle, ...reviews, price], horizontal, variantTitle.length > 0);
   const card = (sections) => [
     {
@@ -3552,9 +3570,9 @@ var buildCarouselNav = () => ({
   sectionType: "layout"
 });
 var HEADER_FIELDS = ["superTitle", "title", "description"];
-var sanitizedHeader = (language2) => Object.fromEntries(
+var sanitizedHeader = (language3) => Object.fromEntries(
   HEADER_FIELDS.flatMap((field) => {
-    const value = language2?.[field];
+    const value = language3?.[field];
     const sanitized = value ? stripContentBlockHtml(normalizeTokens(value)) : "";
     return sanitized ? [[field, sanitized]] : [];
   })
@@ -3651,7 +3669,7 @@ var coerceIntegrations = (integrations) => Object.fromEntries(
     return [key, value];
   })
 );
-var buildBanner = (language2) => language2?.successBannerEnabled ? [
+var buildBanner = (language3) => language3?.successBannerEnabled ? [
   {
     /**
      * The banner-level tag is the extraction/routing key on BOTH renderers (React CAB's
@@ -3664,7 +3682,7 @@ var buildBanner = (language2) => language2?.successBannerEnabled ? [
     dismissible: true,
     sections: [
       {
-        content: bannerMessageContent(language2.successBannerMessageRte),
+        content: bannerMessageContent(language3.successBannerMessageRte),
         sectionType: "text"
       },
       {
@@ -3981,14 +3999,14 @@ var convertCalloutBlock = (raw, report) => {
   };
   const shell = Shell.safeParse(raw);
   if (!shell.success) return omit("Unreadable post-purchase callout");
-  const values = fields.map((field) => ({
+  const values2 = fields.map((field) => ({
     field,
     result: CalloutBannerBlock.shape.settings.shape[field].safeParse(shell.data.settings[field])
   }));
-  const styled2 = values.every(({ result }) => result.success && typeof result.data === "string");
+  const styled2 = values2.every(({ result }) => result.success && typeof result.data === "string");
   const styles2 = shell.data.styles;
   const horizontal = styled2 ? { center: "center", leading: "start", trailing: "end" }[styles2.textAlignment] : "center";
-  const sections = values.flatMap(({ field, result }) => {
+  const sections = values2.flatMap(({ field, result }) => {
     if (!result.success) return omit(`Unreadable post-purchase callout field: ${field}`);
     const text2 = result.data;
     if (text2 === "") return [];
@@ -4010,12 +4028,12 @@ var convertCalloutBlock = (raw, report) => {
 var import_zod32 = require("zod");
 
 // src/transforms/postPurchase/sizeImageSource.ts
-var sizeImageSource = (source, size) => {
-  const extension = source.split(".").pop();
+var sizeImageSource = (source2, size) => {
+  const extension = source2.split(".").pop();
   for (const previous of ["small", "medium", "large", "original", "master"]) {
-    source = source.replace(`_${previous}.${extension}`, `.${extension}`);
+    source2 = source2.replace(`_${previous}.${extension}`, `.${extension}`);
   }
-  return source.replace(`.${extension}`, `${size === void 0 ? "" : `_${size}`}.${extension}`);
+  return source2.replace(`.${extension}`, `${size === void 0 ? "" : `_${size}`}.${extension}`);
 };
 
 // src/transforms/postPurchase/convertImageFrame.ts
@@ -4025,9 +4043,9 @@ var convertImageFrame = (raw) => {
   const parsed = ImageBlock.shape.settings.options[0].safeParse(raw);
   if (!parsed.success) return null;
   const settings = parsed.data;
-  const source = sizeImageSource(Source.parse(settings.image || void 0));
-  const withAlt = CABImageSection.safeParse({ altText: settings.alt, source });
-  const image = withAlt.success ? withAlt.data : CABImageSection.parse({ source });
+  const source2 = sizeImageSource(Source.parse(settings.image || void 0));
+  const withAlt = CABImageSection.safeParse({ altText: settings.alt, source: source2 });
+  const image = withAlt.success ? withAlt.data : CABImageSection.parse({ source: source2 });
   const size = settings.imageSize > 0 ? settings.imageSize : DEFAULT_IMAGE_SIZE;
   return CABLayoutSection.parse({
     alignment: { horizontal: "center" },
@@ -4264,19 +4282,19 @@ var convertTextBlock = (raw, report) => {
     report?.({ detail: "Unreadable post-purchase text block", kind: "section" });
     return [];
   }
-  const values = fields3.map((field) => ({
+  const values2 = fields3.map((field) => ({
     field,
     result: settingsSchema.shape[field].safeParse(shell.data.settings[field])
   }));
   const horizontal = { center: "center", leading: "start", trailing: "end" }[shell.data.settings.horizontalAlignment];
-  const styled2 = values.every(
+  const styled2 = values2.every(
     ({ result }) => result.success && (result.data === null || typeof result.data === "string")
   );
   const omit = (field) => {
     report?.({ detail: `Unreadable post-purchase text field: ${field}`, kind: "section" });
     return [];
   };
-  const sections = values.flatMap(({ field, result }) => {
+  const sections = values2.flatMap(({ field, result }) => {
     if (!result.success) return omit(field);
     const text2 = result.data;
     if (text2 === null || text2 === "") return [];
@@ -4510,10 +4528,10 @@ var giftOf = (tier) => {
   if (tier.type !== "product") return void 0;
   const product = tier.products?.[0] ?? tier.allProducts?.[0];
   if (!product) return void 0;
-  const productId = product.productId ?? product.id;
-  if (productId === void 0) return void 0;
+  const productId2 = product.productId ?? product.id;
+  if (productId2 === void 0) return void 0;
   return {
-    productId,
+    productId: productId2,
     title: product.title,
     variantIds: positiveIds(product.variantIds)
   };
@@ -4792,14 +4810,14 @@ function serialize(obj) {
 var encodeAttributes = (pairs = []) => JSON.stringify(Object.fromEntries(pairs.map(({ key, value }) => [key, value ?? ""])));
 var buildEngineParams = (input, key) => {
   const { cart, customerId, filterInputs, integrations, limit, productType, shop, visitorId } = input;
-  const items = cart.items.map(({ productId, properties, quantity, subscriptionId, variantId }) => ({
-    product_id: productId,
+  const items = cart.items.map(({ productId: productId2, properties, quantity: quantity2, subscriptionId, variantId }) => ({
+    product_id: productId2,
     properties: encodeAttributes(properties),
-    quantity,
+    quantity: quantity2,
     ...subscriptionId && { subscription_id: subscriptionId },
     variant_id: variantId
   }));
-  const itemCount = cart.items.reduce((total, { quantity }) => total + quantity, 0);
+  const itemCount = cart.items.reduce((total, { quantity: quantity2 }) => total + quantity2, 0);
   const subtotal = shopSubtotalCents(cart);
   return {
     cart: {
@@ -4886,13 +4904,13 @@ var OFFER_LIMIT = 4;
 var SUPPORTED_COUNTRIES = /* @__PURE__ */ new Set(["US", "CA", "GB"]);
 var MAX_TRANSACTION_ITEMS = 50;
 var TEST_CUSTOMER_EMAIL = "test@rebuyengine.com";
-var transactionItems = (input) => (input.transactionItems?.map(({ id, priceCents, quantity, title, type }) => ({
+var transactionItems = (input) => (input.transactionItems?.map(({ id, priceCents, quantity: quantity2, title, type }) => ({
   id,
   price_cents: priceCents,
-  quantity,
+  quantity: quantity2,
   title,
   type
-})) ?? input.cart.items.map(({ productId, quantity }) => ({ id: productId, quantity }))).slice(0, MAX_TRANSACTION_ITEMS);
+})) ?? input.cart.items.map(({ productId: productId2, quantity: quantity2 }) => ({ id: productId2, quantity: quantity2 }))).slice(0, MAX_TRANSACTION_ITEMS);
 var AdsEngineOffer = import_zod37.z.object({
   /** Pill-style value prop ("Get $45 Cashback"). Carried through the parse; the card does not render it yet (REB-24429 — pill design pending). */
   callout: import_zod37.z.string().catch(""),
@@ -5010,9 +5028,9 @@ var label = (text2) => ({
 });
 var text = (content) => ({ content: { en: content }, sectionType: SectionType.text });
 var AS_DOC = { defaultTextStyle: {} };
-var safeTextValue = (raw, options) => {
-  const converted = normalizeTextValue(raw, options);
-  return checkForHTML(converted) ? converted : normalizeTextValue(htmlToPlainText(raw), options);
+var safeTextValue = (raw, options2) => {
+  const converted = normalizeTextValue(raw, options2);
+  return checkForHTML(converted) ? converted : normalizeTextValue(htmlToPlainText(raw), options2);
 };
 var headlineText = (raw) => {
   const doc = safeTextValue(raw, AS_DOC);
@@ -5496,11 +5514,11 @@ var validateGifts = async (input, ctx) => {
   const [remove, adjust] = await Promise.all([validateGwpGifts(input, ctx), validateSelectableGifts(input, ctx)]);
   const removed = new Set(remove);
   const targets = /* @__PURE__ */ new Map();
-  for (const { lineId, quantity } of adjust) {
+  for (const { lineId, quantity: quantity2 } of adjust) {
     if (removed.has(lineId)) continue;
-    targets.set(lineId, Math.min(quantity, targets.get(lineId) ?? quantity));
+    targets.set(lineId, Math.min(quantity2, targets.get(lineId) ?? quantity2));
   }
-  return { adjust: [...targets].map(([lineId, quantity]) => ({ lineId, quantity })), remove: [...removed] };
+  return { adjust: [...targets].map(([lineId, quantity2]) => ({ lineId, quantity: quantity2 })), remove: [...removed] };
 };
 
 // src/server/normalizePostPurchaseProduct.ts
@@ -5832,14 +5850,14 @@ var SourceAdjustment = import_zod47.z.object({
   type: import_zod47.z.enum(["percentage", "fixed_amount", "amount", "price", "none", "fixed"])
 });
 var readPostPurchasePlanAdjustment = (raw) => {
-  const source = SourceAdjustment.parse(raw);
-  if (source.type === "none" || source.type === "fixed") {
-    if (source.amount !== 0) throw new Error("Unsupported plan adjustment");
+  const source2 = SourceAdjustment.parse(raw);
+  if (source2.type === "none" || source2.type === "fixed") {
+    if (source2.amount !== 0) throw new Error("Unsupported plan adjustment");
     return void 0;
   }
   const adjustment = PostPurchasePlanAdjustment.parse({
-    amount: source.amount,
-    type: source.type === "amount" ? "fixed_amount" : source.type
+    amount: source2.amount,
+    type: source2.type === "amount" ? "fixed_amount" : source2.type
   });
   return adjustment.amount === 0 && adjustment.type !== "price" ? void 0 : adjustment;
 };
@@ -5916,12 +5934,12 @@ var projectPostPurchasePlanCatalog = (normalized, report) => {
     const { data } = normalized;
     if (data.length !== 1 || data[0].variants.length !== 1) throw new Error("Ambiguous product");
     const product = data[0];
-    const variant = product.variants[0];
-    if (variant.productId !== product.id) throw new Error("Foreign variant");
+    const variant2 = product.variants[0];
+    if (variant2.productId !== product.id) throw new Error("Foreign variant");
     const groups = product.sellingPlanGroups;
     const required = groups.map((group) => group.requiresSellingPlan);
     if (required.some((flag) => flag !== required[0])) throw new Error("Conflicting requirement");
-    const plans = typeof groups[0]?.id === "number" ? readPostPurchaseLegacyPlans(groups[0], variant.id) : readPostPurchaseModernPlans(groups, variant.sellingPlanAllocations);
+    const plans = typeof groups[0]?.id === "number" ? readPostPurchaseLegacyPlans(groups[0], variant2.id) : readPostPurchaseModernPlans(groups, variant2.sellingPlanAllocations);
     const unique = /* @__PURE__ */ new Map();
     for (const plan of plans) {
       const previous = unique.get(plan.id);
@@ -5932,7 +5950,7 @@ var projectPostPurchasePlanCatalog = (normalized, report) => {
       plans: [...unique.values()],
       productId: product.id,
       requiresSellingPlan: required[0] ?? false,
-      variantId: variant.id
+      variantId: variant2.id
     });
   } catch {
     report?.({ detail: "Unreadable post-purchase plan catalog", kind: "product" });
@@ -5969,14 +5987,10 @@ var PostPurchasePrimaryImageSource = import_zod51.z.string().default(
   "https://cdn.shopify.com/shopifycloud/shopify/assets/no-image-2048-5e88c1b20e087fb7bbe9a3771824e743c244f437e4f8ba93bbf7b11b53f7824c.gif"
 );
 var PostPurchaseProductDisplay = import_zod51.z.object({
+  descriptionDocument: TiptapDocument.optional(),
   discountedFrom: PostPurchaseSettings.shape.discountedFrom,
   gallery: PostPurchaseProductGallery.optional(),
-  language: language.pick({
-    description: true,
-    descriptionEnabled: true,
-    descriptionRte: true,
-    descriptionSpacing: true
-  }),
+  language: language.pick({ description: true, descriptionEnabled: true }),
   primaryImage: import_zod51.z.object({ description: import_zod51.z.string(), source: import_zod51.z.string() }),
   productOptions: PostPurchaseSettings.shape.productOptions.pick({
     showDeclineAll: true,
@@ -6072,20 +6086,20 @@ var PostPurchaseSubscriptionSettings = subscription.extend({
 });
 
 // src/server/postPurchaseVariantAvailable.ts
-var postPurchaseVariantAvailable = (variant) => !(variant.inventoryManagement && variant.inventoryPolicy === "deny" && variant.inventoryQuantity <= 0);
+var postPurchaseVariantAvailable = (variant2) => !(variant2.inventoryManagement && variant2.inventoryPolicy === "deny" && variant2.inventoryQuantity <= 0);
 
 // src/server/postPurchaseSubscriptionEligibility.ts
-var subscriptionUnavailable = (normalized, plan, allowCollection, quantity) => {
+var subscriptionUnavailable = (normalized, plan, allowCollection, quantity2) => {
   const { data, effective, original } = normalized;
   const unavailable = "An eligible subscription plan with supported shipping and discount is required";
   if (data.length !== 1 || data[0].variants.length !== 1) return unavailable;
   if (effective.productType === "one-time" || [original, effective].some(
-    (config) => !allowCollection && config.productLimit !== 1 || config.upgradeToSubscription.allow || !quantity && config.quantityInputs.enabled && (config.quantityInputs.minValue !== config.quantityInputs.maxValue || config.quantityInputs.defaultQuantity !== config.quantityInputs.minValue)
+    (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 unavailable;
   const product = data[0];
-  const variant = product.variants[0];
-  if (product.productGroupVariants.length || !postPurchaseVariantAvailable(variant) || variant.productId !== product.id)
+  const variant2 = product.variants[0];
+  if (product.productGroupVariants.length || !postPurchaseVariantAvailable(variant2) || variant2.productId !== product.id)
     return unavailable;
   const terms = [original, effective].map(
     (config) => PostPurchaseSubscriptionSettings.safeParse(config.subscription)
@@ -6094,14 +6108,14 @@ var subscriptionUnavailable = (normalized, plan, allowCollection, quantity) => {
 };
 
 // src/server/postPurchaseProductDisplay.ts
-var import_zod55 = require("zod");
+var import_zod56 = require("zod");
 
 // src/server/postPurchasePrimaryImage.ts
 var postPurchasePrimaryImage = (product) => {
   const variantImageId = product.variants[0].imageId;
   const selectedImage = variantImageId ? product.images?.find((image) => image.id === variantImageId) : void 0;
-  const source = PostPurchasePrimaryImageSource.parse((selectedImage ?? product.image)?.src || void 0);
-  return { description: product.title, source: sizeImageSource(source, "800x800") };
+  const source2 = PostPurchasePrimaryImageSource.parse((selectedImage ?? product.image)?.src || void 0);
+  return { description: product.title, source: sizeImageSource(source2, "800x800") };
 };
 
 // src/server/postPurchaseProductGallery.ts
@@ -6115,9 +6129,67 @@ var postPurchaseProductGallery = (product, limit) => ({
   selectedImageId: product.images?.find((image) => image.id === product.variants[0].imageId)?.id
 });
 
+// src/transforms/postPurchase/convertDescriptionRte.ts
+var import_zod55 = 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_zod55.z.object({
+  attrs: import_zod55.z.object({ alignment: import_zod55.z.enum(["left", "center", "right"]).optional().catch(void 0) }).catch({}),
+  content: import_zod55.z.array(import_zod55.z.unknown()).catch([]),
+  type: import_zod55.z.literal("ShopifyTextBlock")
+});
+var Run = import_zod55.z.object({ marks: import_zod55.z.array(import_zod55.z.unknown()).catch([]), text: import_zod55.z.string().min(1), type: import_zod55.z.literal("text") });
+var Inline = import_zod55.z.object({
+  attrs: import_zod55.z.object({
+    color: import_zod55.z.enum(colors).optional().catch(void 0),
+    emphasis: import_zod55.z.array(import_zod55.z.unknown()).catch([]),
+    size: import_zod55.z.enum(sizes2).optional().catch(void 0)
+  }),
+  type: import_zod55.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_zod56.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,
@@ -6130,26 +6202,26 @@ var projectPostPurchaseProductDisplay = (effective, metadata, product) => PostPu
 // src/server/projectPostPurchaseProduct.ts
 var projectPostPurchaseProduct = ({ data, effective, metadata, original }, selectedQuantity) => {
   const product = data[0];
-  const variant = product.variants[0];
+  const variant2 = product.variants[0];
   return {
     display: projectPostPurchaseProductDisplay(effective, metadata, product),
     labels: effective.language.global,
-    product: { ...product, variant },
+    product: { ...product, variant: variant2 },
     selection: {
       productId: product.id,
       quantity: selectedQuantity?.quantity ?? product.metadata?.productQuantity ?? (original.quantityInputs.enabled ? original.quantityInputs.defaultQuantity : 1),
-      variantId: variant.id
+      variantId: variant2.id
     }
   };
 };
 
 // src/server/prepareNormalizedSubscription.ts
-var prepareNormalizedSubscription = (normalized, report, plan, quantity, allowCollection = false) => {
+var prepareNormalizedSubscription = (normalized, report, plan, quantity2, allowCollection = false) => {
   if (!plan) return { reason: "Subscription plan is unavailable", status: "unsupported" };
-  const reason = subscriptionUnavailable(normalized, plan, allowCollection, quantity);
+  const reason = subscriptionUnavailable(normalized, plan, allowCollection, quantity2);
   if (reason) return { reason, status: "unsupported" };
   const { effective } = normalized;
-  const projected = projectPostPurchaseProduct(normalized, quantity);
+  const projected = projectPostPurchaseProduct(normalized, quantity2);
   const { discount, shipping } = PostPurchaseSubscriptionSettings.parse(effective.subscription);
   const shippingPrice = shipping.type === "free" ? 0 : shipping.amount;
   return PreparedPostPurchaseSubscription.parse({
@@ -6186,6 +6258,855 @@ var preparePostPurchaseSubscription = (settings, response, report) => {
   );
 };
 
+// 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/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, 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/postPurchaseProductView.ts
+var import_zod60 = require("zod");
+
+// src/schema/postPurchaseChoice.ts
+var import_zod57 = require("zod");
+var PostPurchaseChoice = import_zod57.z.discriminatedUnion("mode", [
+  import_zod57.z.object({ mode: import_zod57.z.literal("one-time") }).strict(),
+  import_zod57.z.object({ mode: import_zod57.z.literal("subscription"), sellingPlanId: PostPurchasePlanOption.shape.id }).strict()
+]);
+var PostPurchaseOptions = import_zod57.z.object({
+  defaultChoice: PostPurchaseChoice,
+  modes: import_zod57.z.array(import_zod57.z.enum(["one-time", "subscription"])).min(1).max(2),
+  selector: PostPurchaseSettings.shape.productTypeSelector
+});
+
+// src/schema/postPurchaseGroupCatalog.ts
+var import_zod59 = require("zod");
+
+// src/schema/postPurchaseVariantCatalog.ts
+var import_zod58 = require("zod");
+var PostPurchaseVariantSelector = import_zod58.z.object({ variantId: PostPurchaseVariantId }).strict();
+var PostPurchaseVariantOption = OfferProduct.shape.options.element.extend({
+  id: import_zod58.z.number().int().positive(),
+  position: import_zod58.z.number().int().min(1).max(3)
+});
+var PostPurchaseVariantValues = OfferProduct.shape.variants.element.pick({
+  option1: true,
+  option2: true,
+  option3: true
+});
+var PostPurchaseVariantCatalog = import_zod58.z.object({
+  displayMode: PostPurchaseSettings.shape.productOptions.shape.variantSelectorDisplayMode,
+  options: import_zod58.z.array(PostPurchaseVariantOption),
+  productId: PostPurchaseProductId,
+  showSelectors: PostPurchaseSettings.shape.productOptions.shape.showVariantSelectors,
+  variants: import_zod58.z.array(
+    PostPurchaseVariantValues.partial().extend({
+      available: import_zod58.z.boolean(),
+      id: PostPurchaseVariantId,
+      imageId: import_zod58.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_zod59.z.object({
+  memberProductId: productId,
+  options: import_zod59.z.array(import_zod59.z.object({ productId, title: import_zod59.z.string(), variantCatalog: PostPurchaseVariantCatalog }))
+});
+var PostPurchaseGroupSelection = import_zod59.z.object({
+  memberProductId: productId,
+  productId
+});
+
+// src/schema/postPurchaseProductView.ts
+var PostPurchaseProductView = import_zod60.z.union([
+  import_zod60.z.object({
+    groupCatalog: PostPurchaseGroupCatalog.optional(),
+    initialVariant: PostPurchaseVariantSelector.optional(),
+    planCatalog: PostPurchasePlanCatalog.nullable().optional(),
+    preparation: PreparedPostPurchaseProduct.extend({
+      display: PreparedPostPurchaseProduct.shape.display.extend({ description: import_zod60.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_zod60.z.object({
+    groupCatalog: PostPurchaseGroupCatalog.optional(),
+    initialVariant: PostPurchaseVariantSelector.optional(),
+    planCatalog: PostPurchasePlanCatalog.nullable().optional(),
+    preparation: PostPurchasePreparation.options[1],
+    purchaseOptions: PostPurchaseOptions.optional(),
+    sections: import_zod60.z.null(),
+    variantCatalog: PostPurchaseVariantCatalog.optional()
+  })
+]);
+
+// src/server/postPurchaseOfferCopy.ts
+var import_zod61 = require("zod");
+var Copy = import_zod61.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_zod61.z.object({ settings: import_zod61.z.record(import_zod61.z.string(), import_zod61.z.unknown()), type: import_zod61.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_zod62 = require("zod");
+var PostPurchaseProductCollectionView = import_zod62.z.object({
+  members: import_zod62.z.array(
+    import_zod62.z.object({
+      productId: PostPurchaseProductId,
+      productIndex: import_zod62.z.number().int().nonnegative(),
+      view: PostPurchaseProductView
+    })
+  )
+});
+var PostPurchaseCollectionChoice = import_zod62.z.object({
+  choice: PostPurchaseChoice.optional(),
+  productId: PostPurchaseProductId,
+  variantId: PostPurchaseVariantSelector.shape.variantId.optional()
+}).strict();
+var PostPurchaseExcludedProductIds = import_zod62.z.array(PostPurchaseProductId).default([]);
+
+// src/server/normalizePostPurchaseCollection.ts
+var import_zod63 = require("zod");
+var normalizePostPurchaseCollection = (settings, response, excludedProductIds) => {
+  const normalized = normalizePostPurchaseProduct(settings, response);
+  const limit = import_zod63.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);
+  const variants = product.variants.map((variant2) => ({
+    ...variant2,
+    ...PostPurchaseVariantValues.partial().parse(variant2)
+  }));
+  const tuples = variants.map(({ option1, option2, option3 }) => [option1, option2, option3]);
+  if (new Set(product.variants.map(({ id }) => id)).size !== product.variants.length || product.variants.some(({ productId: productId2 }) => productId2 !== product.id) || new Set(options2.map(({ id }) => id)).size !== options2.length || options2.some(
+    ({ position, values: values2 }, index) => position !== index + 1 || new Set(values2).size !== values2.length
+  ) || product.variants.length > 1 && new Set(tuples.map((tuple) => JSON.stringify(tuple))).size !== tuples.length)
+    throw new Error("Ambiguous post-purchase variant catalog");
+  for (const tuple of tuples) {
+    if (options2.some(({ position, values: values2 }) => !values2.some((value) => value === tuple[position - 1])) || tuple.some((value, index) => value != null && !options2[index]))
+      throw new Error("Variant option tuple does not match the catalog");
+  }
+  return PostPurchaseVariantCatalog.parse({
+    displayMode: settings.productOptions.variantSelectorDisplayMode,
+    options: options2,
+    productId: product.id,
+    showSelectors: settings.productOptions.showVariantSelectors,
+    variants: variants.map(({ id, imageId, option1, option2, option3, title, ...inventory }) => ({
+      available: postPurchaseVariantAvailable(inventory),
+      id,
+      imageId,
+      option1,
+      option2,
+      option3,
+      title
+    }))
+  });
+};
+
+// src/schema/postPurchaseQuantity.ts
+var import_zod64 = 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_zod64.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_zod65 = require("zod");
+var values = PostPurchaseVariantValues.partial().extend({
+  option1: PostPurchaseVariantValues.shape.option1.nullish()
+});
+var variant = values.extend({
+  id: PostPurchaseVariantId,
+  inventoryManagement: import_zod65.z.string().nullable(),
+  inventoryPolicy: import_zod65.z.string(),
+  inventoryQuantity: import_zod65.z.number()
+});
+var options = import_zod65.z.array(PostPurchaseVariantOption.pick({ name: true, values: true }));
+var PostPurchaseVariantDefaultProduct = import_zod65.z.object({
+  id: PostPurchaseProductId,
+  options,
+  selectedVariant: variant.optional(),
+  variants: import_zod65.z.array(variant)
+});
+var PostPurchaseVariantDefaultSettings = PostPurchaseSettings.shape.productOptions.pick({
+  hideOutOfStockVariants: true,
+  matchVariant: true
+});
+var PostPurchaseOrderAttributes = import_zod65.z.record(import_zod65.z.string(), import_zod65.z.array(import_zod65.z.string())).default({});
+var PostPurchaseOriginalVariants = import_zod65.z.array(
+  import_zod65.z.object({ productId: PostPurchaseProductId, variantId: PostPurchaseVariantId })
+);
+var PostPurchaseAttributeProducts = import_zod65.z.array(
+  import_zod65.z.object({ id: PostPurchaseProductId, options, variants: import_zod65.z.array(values.extend({ id: PostPurchaseVariantId })) })
+);
+
+// src/schema/postPurchaseVariantDefaultContext.ts
+var import_zod66 = require("zod");
+var PostPurchaseVariantDefaultContext = import_zod66.z.object({
+  enrichedLineItems: import_zod66.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
+var readPostPurchaseGroup = (product, settings, excludedProductIds) => {
+  const descriptions = PostPurchaseGroupDescription.nullable().array().parse(product.productGroupVariants).filter((value) => value !== null);
+  const ids = new Set(descriptions.map((value) => value.id));
+  if (ids.size !== descriptions.length || new Set(product.variants.map(({ id }) => id)).size !== product.variants.length || product.variants.some(({ productId: productId2 }) => !ids.has(productId2)))
+    throw new Error("Ambiguous post-purchase group ownership");
+  const excluded = new Set(PostPurchaseExcludedProductIds.parse(excludedProductIds));
+  const entries = descriptions.map((description) => {
+    const value = {
+      ...product,
+      ...description,
+      images: description.images,
+      productGroupVariants: [],
+      variants: product.variants.filter(({ productId: productId2 }) => productId2 === description.id)
+    };
+    return { product: value, variantCatalog: projectPostPurchaseVariantCatalog(value, settings) };
+  }).filter(({ product: value }) => !excluded.has(value.id));
+  return {
+    catalog: PostPurchaseGroupCatalog.parse({
+      memberProductId: product.id,
+      options: entries.map(({ product: value, variantCatalog }) => ({
+        productId: value.id,
+        title: value.title,
+        variantCatalog
+      }))
+    }),
+    entries
+  };
+};
+
+// 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_zod67 = require("zod");
+var selection2 = PreparedPostPurchaseProduct.shape.selection;
+var PostPurchaseOfferSkipReason = import_zod67.z.enum(["empty", "no-eligible-subscription"]);
+var PostPurchaseOfferEligibilityContext = import_zod67.z.object({
+  excludedProductIds: PostPurchaseExcludedProductIds,
+  originalLineItems: import_zod67.z.array(selection2.pick({ productId: true, sellingPlanId: true, variantId: true }))
+});
+var PostPurchaseOfferEligibility = import_zod67.z.discriminatedUnion("status", [
+  import_zod67.z.object({
+    members: import_zod67.z.array(
+      import_zod67.z.object({ productId: selection2.shape.productId, productIndex: import_zod67.z.number().int().nonnegative() })
+    ),
+    status: import_zod67.z.literal("retain")
+  }),
+  import_zod67.z.object({ reason: PostPurchaseOfferSkipReason, status: import_zod67.z.literal("skip") }),
+  import_zod67.z.object({ reason: import_zod67.z.literal("eligible-upgrade").optional(), status: import_zod67.z.literal("unavailable") })
+]);
+
+// src/server/postPurchaseMemberEligibility.ts
+var PostPurchaseInventoryUnavailable = class extends Error {
+};
+var postPurchaseMemberEligibility = (normalized, product, excluded) => {
+  if (product.productGroupVariants.length) {
+    const group = readPostPurchaseGroup(product, normalized.effective, excluded);
+    return group.entries.map(({ product: option }) => postPurchaseMemberEligibility(normalized, option)).some(Boolean);
+  }
+  if (!product.variants.length) throw new Error("Unsupported catalog");
+  const variants = projectPostPurchaseVariantCatalog(product, normalized.effective).variants;
+  const catalogs = product.variants.map((variant2) => {
+    const catalog = projectPostPurchasePlanCatalog({
+      ...normalized,
+      data: [{ ...product, variants: [variant2] }]
+    });
+    if (!catalog) throw new Error("Unreadable subscription catalog");
+    if (normalized.effective.productType === "one-time" && catalog.requiresSellingPlan)
+      throw new Error("Unsupported purchase mode");
+    return catalog;
+  });
+  if (!variants.some((variant2) => variant2.available))
+    throw new PostPurchaseInventoryUnavailable("Unavailable inventory");
+  return catalogs.some(
+    (catalog, index) => variants[index].available && (normalized.effective.productType !== "subscription" && !catalog.requiresSellingPlan || normalized.effective.productType !== "one-time" && catalog.plans.length > 0)
+  );
+};
+
+// src/server/classifyPostPurchaseOffer.ts
+var classifyPostPurchaseOffer = (settings, response, context) => {
+  try {
+    const trusted = PostPurchaseOfferEligibilityContext.parse(context);
+    const { members, normalized } = normalizePostPurchaseCollection(settings, response);
+    const configurations = [normalized.original, normalized.effective];
+    const upgrades = configurations.some((config) => config.upgradeToSubscription.allow);
+    const oneTime = new Set(
+      trusted.originalLineItems.filter((line) => line.sellingPlanId === void 0).map((line) => line.variantId)
+    );
+    if (upgrades && members.some(
+      ({ product }) => product.sellingPlanGroups?.length && product.variants.some((variant2) => oneTime.has(variant2.id))
+    ))
+      return { reason: "eligible-upgrade", status: "unavailable" };
+    if (normalized.effective.productType !== "one-time") {
+      configurations.forEach((config) => PostPurchaseSubscriptionSettings.parse(config.subscription));
+    }
+    const classified = members.map((member) => {
+      try {
+        return {
+          ...member,
+          eligible: postPurchaseMemberEligibility(normalized, member.product, trusted.excludedProductIds)
+        };
+      } catch (error) {
+        if (error instanceof PostPurchaseInventoryUnavailable && !member.product.productGroupVariants.length && trusted.excludedProductIds.includes(member.product.id))
+          return { ...member, eligible: false };
+        throw error;
+      }
+    });
+    if (!members.length) return { reason: "empty", status: "skip" };
+    if (upgrades) return { reason: "no-eligible-subscription", status: "skip" };
+    const candidates = classified.filter(
+      ({ product }) => product.productGroupVariants.length ? readPostPurchaseGroup(product, normalized.effective, trusted.excludedProductIds).entries.length > 0 : !trusted.excludedProductIds.includes(product.id)
+    );
+    if (!candidates.length) return { reason: "empty", status: "skip" };
+    const retained = candidates.filter(({ eligible }) => eligible);
+    return retained.length ? {
+      members: retained.map(({ product, productIndex }) => ({
+        productId: product.id,
+        productIndex
+      })),
+      status: "retain"
+    } : { reason: "no-eligible-subscription", status: "skip" };
+  } catch {
+    return { status: "unavailable" };
+  }
+};
+
+// src/server/preparePostPurchaseGroupDeclineDisplay.ts
+var preparePostPurchaseGroupDeclineDisplay = (settings, response, requested, excludedProductIds) => {
+  const group = readPostPurchaseGroupSelection(settings, response, requested, excludedProductIds);
+  const variant2 = group?.variantCatalog.variants.find(({ id }) => id === requested.variantId);
+  return group && variant2 ? {
+    display: {
+      productTitle: group.reportingProduct.title,
+      variantId: variant2.id,
+      variantTitle: variant2.title
+    },
+    productIndex: group.productIndex
+  } : null;
+};
+
+// src/server/preparePostPurchaseOfferPresentation.ts
+var import_compat7 = require("es-toolkit/compat");
+var import_zod69 = require("zod");
+
+// src/schema/postPurchaseOfferPresentation.ts
+var import_zod68 = require("zod");
+var language2 = PostPurchaseSettings.shape.language.shape.global.unwrap().unwrap();
+var PostPurchaseOfferPresentation = import_zod68.z.strictObject({
+  labels: language2.pick({ declineAll: true, declineThisOffer: true }),
+  layout: PostPurchaseSettings.shape.offersLayout,
+  sections: CABRootSection.nullable(),
+  showDeclineAll: PostPurchaseSettings.shape.productOptions.shape.showDeclineAll
+});
+
+// src/server/preparePostPurchaseOfferPresentation.ts
+var FrameSettings = PostPurchaseSettings.pick({ language: true, offersLayout: true, productOptions: true }).extend({
+  blocks: import_zod69.z.array(import_zod69.z.unknown()).optional()
+});
+var preparePostPurchaseOfferPresentation = (widgetId, settings, response, report) => {
+  const { metadata } = PostPurchaseProductSource.pick({ metadata: true }).parse(deepCamelCase(response));
+  const original = FrameSettings.parse(deepCamelCase(settings));
+  const effective = FrameSettings.parse((0, import_compat7.merge)({}, original, metadata.widget));
+  let sections = null;
+  try {
+    sections = convertMessagePreview(
+      widgetId,
+      { blocks: postPurchaseOfferCopy(effective.blocks, metadata), type: "shopify_post_purchase_extension" },
+      report
+    );
+  } catch (error) {
+    if (!(error instanceof NotFoundError)) throw error;
+  }
+  return PostPurchaseOfferPresentation.parse({
+    labels: effective.language.global,
+    layout: effective.offersLayout,
+    sections,
+    showDeclineAll: effective.productOptions.showDeclineAll
+  });
+};
+
 // src/server/analytics.ts
 var import_es_toolkit7 = require("es-toolkit");
 
@@ -6230,8 +7151,8 @@ var TAXONOMY = {
   "added-to-cart": {
     /** React credits the add to the A/B-selected variant (`defined_noun_id: selectedId`). */
     buildDefinedNounId: ({ selectedId }) => selectedId != null ? String(selectedId) : void 0,
-    buildMeta: ({ productId, variantId }) => ({
-      ...productId != null && { [`product_id:${productId}`]: true },
+    buildMeta: ({ productId: productId2, variantId }) => ({
+      ...productId2 != null && { [`product_id:${productId2}`]: true },
       ...variantId != null && { [`variant_id:${variantId}`]: true }
     }),
     buildTags: experimentTags,
@@ -6322,7 +7243,7 @@ var postAnalyticsEvents = async (input, ctx) => {
 };
 
 // src/server/requestSchemas.ts
-var import_zod56 = require("zod");
+var import_zod70 = require("zod");
 var REQUEST_BOUNDS = {
   /** Cart-level attributes per cart. */
   CART_ATTRIBUTES_MAX: 100,
@@ -6353,42 +7274,42 @@ var REQUEST_BOUNDS = {
   /** Rich ads transaction lines — the engine's ads contract. */
   TRANSACTION_ITEMS_MAX: 50
 };
-var KeyValue = import_zod56.z.object({
-  key: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX),
-  value: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_VALUE_MAX).optional()
+var KeyValue = import_zod70.z.object({
+  key: import_zod70.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX),
+  value: import_zod70.z.string().max(REQUEST_BOUNDS.STRING_VALUE_MAX).optional()
 });
-var CartLineInputSchema = import_zod56.z.object({
-  productId: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
-  properties: import_zod56.z.array(KeyValue).max(REQUEST_BOUNDS.LINE_PROPERTIES_MAX).optional(),
-  quantity: import_zod56.z.number(),
-  subscriptionId: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  variantId: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX)
+var CartLineInputSchema = import_zod70.z.object({
+  productId: import_zod70.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  properties: import_zod70.z.array(KeyValue).max(REQUEST_BOUNDS.LINE_PROPERTIES_MAX).optional(),
+  quantity: import_zod70.z.number(),
+  subscriptionId: import_zod70.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  variantId: import_zod70.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX)
 });
-var CartInputSchema = import_zod56.z.object({
-  attributes: import_zod56.z.array(KeyValue).max(REQUEST_BOUNDS.CART_ATTRIBUTES_MAX).optional(),
+var CartInputSchema = import_zod70.z.object({
+  attributes: import_zod70.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_zod56.z.number().optional(),
+  currencyRate: import_zod70.z.number().optional(),
   /** Applied discount codes; the engine evaluates `discount_code` rules against them (sent as `[{code}]`). */
-  discountCodes: import_zod56.z.array(import_zod56.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX)).max(REQUEST_BOUNDS.DISCOUNT_CODES_MAX).optional(),
+  discountCodes: import_zod70.z.array(import_zod70.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_zod56.z.number().optional(),
-  items: import_zod56.z.array(CartLineInputSchema).max(REQUEST_BOUNDS.CART_ITEMS_MAX),
+  discountTotal: import_zod70.z.number().optional(),
+  items: import_zod70.z.array(CartLineInputSchema).max(REQUEST_BOUNDS.CART_ITEMS_MAX),
   /** Presentment subtotal in cents. */
-  subtotal: import_zod56.z.number()
+  subtotal: import_zod70.z.number()
 });
-var UserConfigInputSchema = import_zod56.z.object({ shop: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX) });
-var DataSourceInputSchema = import_zod56.z.object({
+var UserConfigInputSchema = import_zod70.z.object({ shop: import_zod70.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX) });
+var DataSourceInputSchema = import_zod70.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_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  companyLocationId: import_zod70.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
@@ -6397,16 +7318,16 @@ var DataSourceInputSchema = import_zod56.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_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).regex(/^[A-Za-z]{2}$/, "must be an ISO 3166-1 alpha-2 country code (e.g. CA)").transform((value) => value.toUpperCase()).optional(),
-  customerId: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  dataSourcePath: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX),
+  country: import_zod70.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_zod70.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  dataSourcePath: import_zod70.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_zod56.z.enum(["no", "yes"]).optional(),
-  integrations: import_zod56.z.record(import_zod56.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX), import_zod56.z.boolean()).refine((record) => Object.keys(record).length <= REQUEST_BOUNDS.INTEGRATION_KEYS_MAX, {
+  filterInputs: import_zod70.z.enum(["no", "yes"]).optional(),
+  integrations: import_zod70.z.record(import_zod70.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX), import_zod70.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(),
   /**
@@ -6419,31 +7340,31 @@ var DataSourceInputSchema = import_zod56.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_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).regex(/^[A-Za-z0-9-]+$/, "must be a single BCP-47 tag (e.g. fr-CA), not a q-value list").optional(),
-  limit: import_zod56.z.number().max(REQUEST_BOUNDS.LIMIT_MAX),
-  productType: import_zod56.z.enum(["both", "one-time", "subscription"]).optional(),
-  shop: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
-  visitorId: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
-});
-var GiftInputSchema = import_zod56.z.object({
-  cost: import_zod56.z.number(),
-  discounted: import_zod56.z.boolean(),
+  language: import_zod70.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_zod70.z.number().max(REQUEST_BOUNDS.LIMIT_MAX),
+  productType: import_zod70.z.enum(["both", "one-time", "subscription"]).optional(),
+  shop: import_zod70.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  visitorId: import_zod70.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
+});
+var GiftInputSchema = import_zod70.z.object({
+  cost: import_zod70.z.number(),
+  discounted: import_zod70.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_zod56.z.enum(GIFT_KINDS).default("gwp"),
-  lineId: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
-  productId: import_zod56.z.number(),
+  kind: import_zod70.z.enum(GIFT_KINDS).default("gwp"),
+  lineId: import_zod70.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  productId: import_zod70.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_zod56.z.number().int().min(1).default(1),
-  widgetId: import_zod56.z.number()
+  quantity: import_zod70.z.number().int().min(1).default(1),
+  widgetId: import_zod70.z.number()
 });
-var GiftValidationInputSchema = import_zod56.z.object({
+var GiftValidationInputSchema = import_zod70.z.object({
   cart: CartInputSchema,
   /**
    * Buyer's market country — threaded into the per-widget data-source evaluations, which forward it to
@@ -6452,25 +7373,25 @@ var GiftValidationInputSchema = import_zod56.z.object({
    * turns markets off); regex-bound and uppercase-normalized for the same reasons as
    * `DataSourceInputSchema`'s `country`.
    */
-  country: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).regex(/^[A-Za-z]{2}$/, "must be an ISO 3166-1 alpha-2 country code (e.g. CA)").transform((value) => value.toUpperCase()).optional(),
-  customerId: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  gifts: import_zod56.z.array(GiftInputSchema).max(REQUEST_BOUNDS.GIFTS_MAX),
+  country: import_zod70.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_zod70.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  gifts: import_zod70.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_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).regex(/^[A-Za-z0-9-]+$/, "must be a single BCP-47 tag (e.g. fr-CA), not a q-value list").optional(),
-  shop: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
-  visitorId: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
+  language: import_zod70.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_zod70.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  visitorId: import_zod70.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
 });
-var GiftAdjustmentSchema = import_zod56.z.object({
-  lineId: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
-  quantity: import_zod56.z.number().int().nonnegative()
+var GiftAdjustmentSchema = import_zod70.z.object({
+  lineId: import_zod70.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  quantity: import_zod70.z.number().int().nonnegative()
 });
-var GiftValidationResponseSchema = import_zod56.z.object({
-  adjust: import_zod56.z.array(GiftAdjustmentSchema).max(REQUEST_BOUNDS.GIFTS_MAX).default([]),
-  remove: import_zod56.z.array(import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX)).max(REQUEST_BOUNDS.GIFTS_MAX).refine(
+var GiftValidationResponseSchema = import_zod70.z.object({
+  adjust: import_zod70.z.array(GiftAdjustmentSchema).max(REQUEST_BOUNDS.GIFTS_MAX).default([]),
+  remove: import_zod70.z.array(import_zod70.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`"
   )
@@ -6481,47 +7402,47 @@ var GiftValidationResponseSchema = import_zod56.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_zod56.z.object({
-  id: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
-  priceCents: import_zod56.z.number(),
-  quantity: import_zod56.z.number(),
-  title: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX),
-  type: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX)
-});
-var MonetizeInputSchema = import_zod56.z.object({
+var MonetizeTransactionItemSchema = import_zod70.z.object({
+  id: import_zod70.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  priceCents: import_zod70.z.number(),
+  quantity: import_zod70.z.number(),
+  title: import_zod70.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX),
+  type: import_zod70.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX)
+});
+var MonetizeInputSchema = import_zod70.z.object({
   cart: CartInputSchema,
   /** Client-minted render-beacon correlation id; forwarded to the ads engine as `client_request_id`. */
-  clientRequestId: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  country: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  currency: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  clientRequestId: import_zod70.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  country: import_zod70.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  currency: import_zod70.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_zod56.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
-  customerFirstName: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
-  customerId: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  customerLastName: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
-  language: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  customerEmail: import_zod70.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
+  customerFirstName: import_zod70.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
+  customerId: import_zod70.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  customerLastName: import_zod70.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
+  language: import_zod70.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_zod56.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
+  orderName: import_zod70.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_zod56.z.enum(["customer_account", "order_status", "thank_you_page"]),
+  placement: import_zod70.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_zod56.z.string().max(REQUEST_BOUNDS.STRING_URL_MAX).optional(),
+  privacyPolicyUrl: import_zod70.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_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  shop: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  sessionId: import_zod70.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  shop: import_zod70.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_zod56.z.boolean().optional(),
-  timezone: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  testing: import_zod70.z.boolean().optional(),
+  timezone: import_zod70.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
   /** Decorated (numeric) order id → the ads `transaction_id`. */
-  transactionId: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  transactionId: import_zod70.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_zod56.z.array(MonetizeTransactionItemSchema).max(REQUEST_BOUNDS.TRANSACTION_ITEMS_MAX).optional(),
+  transactionItems: import_zod70.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_zod56.z.number().optional(),
-  visitorId: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  zipCode: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
+  transactionTotal: import_zod70.z.number().optional(),
+  visitorId: import_zod70.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  zipCode: import_zod70.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
 });
-var WidgetSettingsInputSchema = import_zod56.z.object({
+var WidgetSettingsInputSchema = import_zod70.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
@@ -6529,9 +7450,9 @@ var WidgetSettingsInputSchema = import_zod56.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_zod56.z.number().int().positive().optional().catch(void 0),
-  id: import_zod56.z.number(),
-  key: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  cacheKey: import_zod70.z.number().int().positive().optional().catch(void 0),
+  id: import_zod70.z.number(),
+  key: import_zod70.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`
@@ -6540,34 +7461,34 @@ var WidgetSettingsInputSchema = import_zod56.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_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  shop: import_zod70.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
   /** Stable per-buyer id; when present, enables sticky server-side A/B variant selection. */
-  visitorId: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
+  visitorId: import_zod70.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
 });
-var AnalyticsEventInputSchema = import_zod56.z.object({
-  name: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX),
-  properties: import_zod56.z.record(import_zod56.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX), import_zod56.z.unknown()).optional(),
-  sentAt: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
+var AnalyticsEventInputSchema = import_zod70.z.object({
+  name: import_zod70.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX),
+  properties: import_zod70.z.record(import_zod70.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX), import_zod70.z.unknown()).optional(),
+  sentAt: import_zod70.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
 });
-var AnalyticsSegmentsInputSchema = import_zod56.z.object({
-  device: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional().catch(void 0),
-  source: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional().catch(void 0),
-  visitor: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional().catch(void 0)
+var AnalyticsSegmentsInputSchema = import_zod70.z.object({
+  device: import_zod70.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional().catch(void 0),
+  source: import_zod70.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional().catch(void 0),
+  visitor: import_zod70.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional().catch(void 0)
 });
-var AnalyticsInputSchema = import_zod56.z.object({
+var AnalyticsInputSchema = import_zod70.z.object({
   /** Rebuy cart token (the `r_cart_token` cart attribute), when available — primary aggregation key. */
-  cartToken: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  cartToken: import_zod70.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
   /** Shopify checkout token, when available — drives cart/checkout aggregation downstream. */
-  checkoutToken: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  events: import_zod56.z.array(AnalyticsEventInputSchema).max(REQUEST_BOUNDS.EVENTS_MAX),
+  checkoutToken: import_zod70.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  events: import_zod70.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_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
-  visitorId: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  shop: import_zod70.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  visitorId: import_zod70.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
   /** The widget id (smartBlockId) the events belong to. */
-  widgetId: import_zod56.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
+  widgetId: import_zod70.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
 });