@rebuy/rebuy 3.33.0 → 3.35.0

package/dist/server/index.cjs

@@ -33,18 +33,25 @@ __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,
+  preparePostPurchaseGroupDeclineDisplay: () => preparePostPurchaseGroupDeclineDisplay,
+  preparePostPurchaseOfferPresentation: () => preparePostPurchaseOfferPresentation,
   preparePostPurchaseSubscription: () => preparePostPurchaseSubscription,
+  readPostPurchaseGroupSelection: () => readPostPurchaseGroupSelection,
+  readPostPurchaseQuantity: () => readPostPurchaseQuantity,
   translateAnalyticsEvent: () => translateAnalyticsEvent,
   validateGifts: () => validateGifts
 });
@@ -679,7 +686,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 +2152,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`",
@@ -2265,10 +2272,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 +2387,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({
@@ -2653,15 +2660,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 +2913,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 +2948,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
   };
 };
 
@@ -3397,23 +3404,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 +3430,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 +3444,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 +3501,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 +3559,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 +3658,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 +3671,7 @@ var buildBanner = (language2) => language2?.successBannerEnabled ? [
     dismissible: true,
     sections: [
       {
-        content: bannerMessageContent(language2.successBannerMessageRte),
+        content: bannerMessageContent(language3.successBannerMessageRte),
         sectionType: "text"
       },
       {
@@ -3981,14 +3988,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 +4017,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 +4032,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 +4271,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 +4517,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 +4799,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 +4893,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 +5017,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 +5503,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 +5839,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 +5923,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 +5939,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" });
@@ -6072,20 +6079,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)
@@ -6100,8 +6107,8 @@ var import_zod55 = require("zod");
 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
@@ -6130,26 +6137,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 +6193,412 @@ var preparePostPurchaseSubscription = (settings, response, report) => {
   );
 };
 
+// src/schema/postPurchaseOfferEligibility.ts
+var import_zod57 = require("zod");
+
+// src/schema/postPurchaseProductCollectionView.ts
+var import_zod56 = require("zod");
+var PostPurchaseExcludedProductIds = import_zod56.z.array(PostPurchaseProductId).default([]);
+
+// src/schema/postPurchaseOfferEligibility.ts
+var selection = PreparedPostPurchaseProduct.shape.selection;
+var PostPurchaseOfferSkipReason = import_zod57.z.enum(["empty", "no-eligible-subscription"]);
+var PostPurchaseOfferEligibilityContext = import_zod57.z.object({
+  excludedProductIds: PostPurchaseExcludedProductIds,
+  originalLineItems: import_zod57.z.array(selection.pick({ productId: true, sellingPlanId: true, variantId: true }))
+});
+var PostPurchaseOfferEligibility = import_zod57.z.discriminatedUnion("status", [
+  import_zod57.z.object({
+    members: import_zod57.z.array(
+      import_zod57.z.object({ productId: selection.shape.productId, productIndex: import_zod57.z.number().int().nonnegative() })
+    ),
+    status: import_zod57.z.literal("retain")
+  }),
+  import_zod57.z.object({ reason: PostPurchaseOfferSkipReason, status: import_zod57.z.literal("skip") }),
+  import_zod57.z.object({ reason: import_zod57.z.literal("eligible-upgrade").optional(), status: import_zod57.z.literal("unavailable") })
+]);
+
+// src/server/normalizePostPurchaseCollection.ts
+var import_zod58 = require("zod");
+var normalizePostPurchaseCollection = (settings, response, excludedProductIds) => {
+  const normalized = normalizePostPurchaseProduct(settings, response);
+  const limit = import_zod58.z.number().int().positive();
+  limit.parse(normalized.original.productLimit);
+  const prefix = normalized.data.slice(0, limit.parse(normalized.effective.productLimit));
+  if (new Set(prefix.map(({ id }) => id)).size !== prefix.length)
+    throw new Error("Ambiguous post-purchase collection");
+  const excluded = new Set(PostPurchaseExcludedProductIds.parse(excludedProductIds));
+  const members = prefix.map((product, productIndex) => ({ product, productIndex })).filter(({ product }) => !excluded.has(product.id));
+  return { members, normalized };
+};
+
+// src/schema/postPurchaseVariantCatalog.ts
+var import_zod59 = require("zod");
+var PostPurchaseVariantSelector = import_zod59.z.object({ variantId: PostPurchaseVariantId }).strict();
+var PostPurchaseVariantOption = OfferProduct.shape.options.element.extend({
+  id: import_zod59.z.number().int().positive(),
+  position: import_zod59.z.number().int().min(1).max(3)
+});
+var PostPurchaseVariantValues = OfferProduct.shape.variants.element.pick({
+  option1: true,
+  option2: true,
+  option3: true
+});
+var PostPurchaseVariantCatalog = import_zod59.z.object({
+  displayMode: PostPurchaseSettings.shape.productOptions.shape.variantSelectorDisplayMode,
+  options: import_zod59.z.array(PostPurchaseVariantOption),
+  productId: PostPurchaseProductId,
+  showSelectors: PostPurchaseSettings.shape.productOptions.shape.showVariantSelectors,
+  variants: import_zod59.z.array(
+    PostPurchaseVariantValues.partial().extend({
+      available: import_zod59.z.boolean(),
+      id: PostPurchaseVariantId,
+      imageId: import_zod59.z.number().int().nonnegative().nullish(),
+      title: OfferProduct.shape.variants.element.shape.title
+    })
+  )
+});
+
+// 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/postPurchaseGroupCatalog.ts
+var import_zod60 = require("zod");
+var productId = PreparedPostPurchaseProduct.shape.selection.shape.productId;
+var source = PostPurchaseProductSource.shape.data.element;
+var PostPurchaseGroupDescription = source.pick({ description: true, id: true, image: true, images: true, title: true }).extend({
+  description: source.shape.description.default(null),
+  image: source.shape.image.default(null),
+  options: PostPurchaseVariantCatalog.shape.options.default([])
+});
+var PostPurchaseGroupCatalog = import_zod60.z.object({
+  memberProductId: productId,
+  options: import_zod60.z.array(import_zod60.z.object({ productId, title: import_zod60.z.string(), variantCatalog: PostPurchaseVariantCatalog }))
+});
+var PostPurchaseGroupSelection = import_zod60.z.object({
+  memberProductId: productId,
+  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/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/schema/postPurchaseVariantDefault.ts
+var import_zod61 = require("zod");
+var values = PostPurchaseVariantValues.partial().extend({
+  option1: PostPurchaseVariantValues.shape.option1.nullish()
+});
+var variant = values.extend({
+  id: PostPurchaseVariantId,
+  inventoryManagement: import_zod61.z.string().nullable(),
+  inventoryPolicy: import_zod61.z.string(),
+  inventoryQuantity: import_zod61.z.number()
+});
+var options = import_zod61.z.array(PostPurchaseVariantOption.pick({ name: true, values: true }));
+var PostPurchaseVariantDefaultProduct = import_zod61.z.object({
+  id: PostPurchaseProductId,
+  options,
+  selectedVariant: variant.optional(),
+  variants: import_zod61.z.array(variant)
+});
+var PostPurchaseVariantDefaultSettings = PostPurchaseSettings.shape.productOptions.pick({
+  hideOutOfStockVariants: true,
+  matchVariant: true
+});
+var PostPurchaseOrderAttributes = import_zod61.z.record(import_zod61.z.string(), import_zod61.z.array(import_zod61.z.string())).default({});
+var PostPurchaseOriginalVariants = import_zod61.z.array(
+  import_zod61.z.object({ productId: PostPurchaseProductId, variantId: PostPurchaseVariantId })
+);
+var PostPurchaseAttributeProducts = import_zod61.z.array(
+  import_zod61.z.object({ id: PostPurchaseProductId, options, variants: import_zod61.z.array(values.extend({ id: PostPurchaseVariantId })) })
+);
+
+// src/server/createPostPurchaseOrderAttributes.ts
+var createPostPurchaseOrderAttributes = (original, enriched) => {
+  const products = PostPurchaseAttributeProducts.parse(enriched);
+  const attributes = {};
+  for (const item of PostPurchaseOriginalVariants.parse(original)) {
+    const product = products.find(({ id }) => id === item.productId);
+    const variant2 = product?.variants.find(({ id }) => id === item.variantId);
+    if (!variant2 || !product) continue;
+    ["option1", "option2", "option3"].forEach((key, index) => {
+      const value = variant2[key];
+      const option = product.options[index];
+      if (!value || !option) return;
+      const values2 = attributes[option.name] ?? [];
+      if (!values2.includes(value)) attributes[option.name] = [...values2, value];
+    });
+  }
+  return attributes;
+};
+
+// src/server/readPostPurchaseGroupSelection.ts
+var readPostPurchaseGroupSelection = (settings, response, requested, excludedProductIds) => {
+  const selection2 = PostPurchaseGroupSelection.parse(requested);
+  const { members, normalized } = normalizePostPurchaseCollection(settings, response);
+  const member = members.find(({ product }) => product.id === selection2.memberProductId);
+  if (!member || !member.product.productGroupVariants.length) return null;
+  const group = readPostPurchaseGroup(member.product, normalized.effective, excludedProductIds);
+  const entry = group.entries.find(({ product }) => product.id === selection2.productId);
+  if (!entry) return null;
+  return {
+    groupCatalog: group.catalog,
+    memberProductId: member.product.id,
+    productIndex: member.productIndex,
+    reportingProduct: { id: member.product.id, title: member.product.title },
+    response: { data: [entry.product], metadata: normalized.metadata },
+    variantCatalog: entry.variantCatalog
+  };
+};
+
+// src/server/preparePostPurchaseGroupDeclineDisplay.ts
+var preparePostPurchaseGroupDeclineDisplay = (settings, response, requested, excludedProductIds) => {
+  const group = readPostPurchaseGroupSelection(settings, response, requested, excludedProductIds);
+  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_zod64 = require("zod");
+
+// src/schema/postPurchaseOfferPresentation.ts
+var import_zod62 = require("zod");
+var language2 = PostPurchaseSettings.shape.language.shape.global.unwrap().unwrap();
+var PostPurchaseOfferPresentation = import_zod62.z.strictObject({
+  labels: language2.pick({ declineAll: true, declineThisOffer: true }),
+  layout: PostPurchaseSettings.shape.offersLayout,
+  sections: CABRootSection.nullable(),
+  showDeclineAll: PostPurchaseSettings.shape.productOptions.shape.showDeclineAll
+});
+
+// src/server/postPurchaseOfferCopy.ts
+var import_zod63 = require("zod");
+var Copy = import_zod63.z.object({
+  superTitle: CalloutBannerBlock.shape.settings.shape.superTitle.unwrap().optional().catch(void 0),
+  title: CalloutBannerBlock.shape.settings.shape.title.unwrap().optional().catch(void 0)
+});
+var Callout = import_zod63.z.object({ settings: import_zod63.z.record(import_zod63.z.string(), import_zod63.z.unknown()), type: import_zod63.z.literal("callout_banner") });
+var postPurchaseOfferCopy = (blocks, metadata) => {
+  const copy = Copy.safeParse(metadata.widget.language);
+  if (!blocks || !copy.success) return blocks;
+  const first = blocks.findIndex((block) => Callout.pick({ type: true }).safeParse(block).success);
+  return blocks.map((block, index) => {
+    if (index !== first) return block;
+    const callout = Callout.passthrough().safeParse(block);
+    if (!callout.success) return block;
+    return {
+      ...callout.data,
+      settings: {
+        ...callout.data.settings,
+        ...copy.data.title && { title: copy.data.title },
+        ...copy.data.superTitle && { superTitle: copy.data.superTitle }
+      }
+    };
+  });
+};
+
+// src/server/preparePostPurchaseOfferPresentation.ts
+var FrameSettings = PostPurchaseSettings.pick({ language: true, offersLayout: true, productOptions: true }).extend({
+  blocks: import_zod64.z.array(import_zod64.z.unknown()).optional()
+});
+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/schema/postPurchaseQuantity.ts
+var import_zod65 = require("zod");
+var quantity = PreparedPostPurchaseProduct.shape.selection.shape.quantity;
+var PostPurchaseQuantityPolicy = PostPurchaseSettings.shape.quantityInputs.omit({ defaultQuantity: true }).extend({
+  initialQuantity: quantity,
+  maxValue: quantity,
+  minValue: import_zod65.z.literal(0).transform(() => 1).or(quantity)
+}).refine(({ maxValue, minValue }) => minValue <= maxValue, "Quantity bounds are reversed");
+
+// src/server/readPostPurchaseQuantity.ts
+var PostPurchaseQuantityUnavailable = class extends Error {
+};
+var readPostPurchaseQuantity = ({
+  data,
+  effective,
+  original
+}, selection2) => {
+  const positive = PreparedPostPurchaseProduct.shape.selection.shape.quantity;
+  for (const config of [original, effective]) {
+    if (!config.quantityInputs.enabled) continue;
+    const initialQuantity2 = positive.parse(config.quantityInputs.defaultQuantity);
+    const policy2 = PostPurchaseQuantityPolicy.parse({ ...config.quantityInputs, initialQuantity: initialQuantity2 });
+    if (initialQuantity2 < policy2.minValue || initialQuantity2 > policy2.maxValue)
+      throw new Error("Configured quantity default is outside its bounds");
+  }
+  const initialQuantity = data[0]?.metadata?.productQuantity ?? (original.quantityInputs.enabled ? original.quantityInputs.defaultQuantity : 1);
+  const policy = PostPurchaseQuantityPolicy.parse(
+    effective.quantityInputs.enabled ? { ...effective.quantityInputs, initialQuantity } : { enabled: false, initialQuantity, maxValue: initialQuantity, minValue: initialQuantity }
+  );
+  const requested = "quantity" in selection2 ? selection2.quantity : selection2.expectedQuantity === initialQuantity ? void 0 : selection2.expectedQuantity;
+  const quantity2 = positive.parse(requested ?? initialQuantity);
+  if (requested !== void 0 && (policy.enabled ? quantity2 < policy.minValue || quantity2 > policy.maxValue : quantity2 !== initialQuantity))
+    throw new PostPurchaseQuantityUnavailable("Requested quantity is unavailable");
+  return { policy, quantity: quantity2 };
+};
+
 // src/server/analytics.ts
 var import_es_toolkit7 = require("es-toolkit");
 
@@ -6230,8 +6643,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 +6735,7 @@ var postAnalyticsEvents = async (input, ctx) => {
 };
 
 // src/server/requestSchemas.ts
-var import_zod56 = require("zod");
+var import_zod66 = require("zod");
 var REQUEST_BOUNDS = {
   /** Cart-level attributes per cart. */
   CART_ATTRIBUTES_MAX: 100,
@@ -6353,42 +6766,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_zod66.z.object({
+  key: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX),
+  value: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_VALUE_MAX).optional()
 });
-var 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_zod66.z.object({
+  productId: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  properties: import_zod66.z.array(KeyValue).max(REQUEST_BOUNDS.LINE_PROPERTIES_MAX).optional(),
+  quantity: import_zod66.z.number(),
+  subscriptionId: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  variantId: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX)
 });
-var CartInputSchema = import_zod56.z.object({
-  attributes: import_zod56.z.array(KeyValue).max(REQUEST_BOUNDS.CART_ATTRIBUTES_MAX).optional(),
+var CartInputSchema = import_zod66.z.object({
+  attributes: import_zod66.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_zod66.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_zod66.z.array(import_zod66.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_zod66.z.number().optional(),
+  items: import_zod66.z.array(CartLineInputSchema).max(REQUEST_BOUNDS.CART_ITEMS_MAX),
   /** Presentment subtotal in cents. */
-  subtotal: import_zod56.z.number()
+  subtotal: import_zod66.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_zod66.z.object({ shop: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX) });
+var DataSourceInputSchema = import_zod66.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_zod66.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 +6810,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_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).regex(/^[A-Za-z]{2}$/, "must be an ISO 3166-1 alpha-2 country code (e.g. CA)").transform((value) => value.toUpperCase()).optional(),
+  customerId: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  dataSourcePath: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX),
   /**
    * 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_zod66.z.enum(["no", "yes"]).optional(),
+  integrations: import_zod66.z.record(import_zod66.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX), import_zod66.z.boolean()).refine((record) => Object.keys(record).length <= REQUEST_BOUNDS.INTEGRATION_KEYS_MAX, {
     message: `Too many integration keys (max ${REQUEST_BOUNDS.INTEGRATION_KEYS_MAX})`
   }).optional(),
   /**
@@ -6419,31 +6832,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_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).regex(/^[A-Za-z0-9-]+$/, "must be a single BCP-47 tag (e.g. fr-CA), not a q-value list").optional(),
+  limit: import_zod66.z.number().max(REQUEST_BOUNDS.LIMIT_MAX),
+  productType: import_zod66.z.enum(["both", "one-time", "subscription"]).optional(),
+  shop: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  visitorId: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
+});
+var GiftInputSchema = import_zod66.z.object({
+  cost: import_zod66.z.number(),
+  discounted: import_zod66.z.boolean(),
   /**
    * 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_zod66.z.enum(GIFT_KINDS).default("gwp"),
+  lineId: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  productId: import_zod66.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_zod66.z.number().int().min(1).default(1),
+  widgetId: import_zod66.z.number()
 });
-var GiftValidationInputSchema = import_zod56.z.object({
+var GiftValidationInputSchema = import_zod66.z.object({
   cart: CartInputSchema,
   /**
    * Buyer's market country — threaded into the per-widget data-source evaluations, which forward it to
@@ -6452,25 +6865,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_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).regex(/^[A-Za-z]{2}$/, "must be an ISO 3166-1 alpha-2 country code (e.g. CA)").transform((value) => value.toUpperCase()).optional(),
+  customerId: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  gifts: import_zod66.z.array(GiftInputSchema).max(REQUEST_BOUNDS.GIFTS_MAX),
   /**
    * 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_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).regex(/^[A-Za-z0-9-]+$/, "must be a single BCP-47 tag (e.g. fr-CA), not a q-value list").optional(),
+  shop: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  visitorId: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
 });
-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_zod66.z.object({
+  lineId: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  quantity: import_zod66.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_zod66.z.object({
+  adjust: import_zod66.z.array(GiftAdjustmentSchema).max(REQUEST_BOUNDS.GIFTS_MAX).default([]),
+  remove: import_zod66.z.array(import_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX)).max(REQUEST_BOUNDS.GIFTS_MAX).refine(
     (remove) => new Set(remove).size === remove.length,
     "a line id may appear at most once in `remove`"
   )
@@ -6481,47 +6894,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_zod66.z.object({
+  id: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  priceCents: import_zod66.z.number(),
+  quantity: import_zod66.z.number(),
+  title: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX),
+  type: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX)
+});
+var MonetizeInputSchema = import_zod66.z.object({
   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_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  country: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  currency: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
   /** 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_zod66.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
+  customerFirstName: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
+  customerId: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  customerLastName: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
+  language: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
   /** 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_zod66.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_zod66.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_zod66.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_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  shop: import_zod66.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_zod66.z.boolean().optional(),
+  timezone: import_zod66.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_zod66.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_zod66.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_zod66.z.number().optional(),
+  visitorId: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  zipCode: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
 });
-var WidgetSettingsInputSchema = import_zod56.z.object({
+var WidgetSettingsInputSchema = import_zod66.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 +6942,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_zod66.z.number().int().positive().optional().catch(void 0),
+  id: import_zod66.z.number(),
+  key: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
   /**
    * 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 +6953,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_zod66.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_zod66.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_zod66.z.object({
+  name: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX),
+  properties: import_zod66.z.record(import_zod66.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX), import_zod66.z.unknown()).optional(),
+  sentAt: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
 });
-var 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_zod66.z.object({
+  device: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional().catch(void 0),
+  source: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional().catch(void 0),
+  visitor: import_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional().catch(void 0)
 });
-var AnalyticsInputSchema = import_zod56.z.object({
+var AnalyticsInputSchema = import_zod66.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_zod66.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_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  events: import_zod66.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_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  visitorId: import_zod66.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_zod66.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
 });