@rebuy/rebuy 3.36.0 → 3.37.0

package/dist/server/index.cjs

@@ -5959,13 +5959,13 @@ var projectPostPurchasePlanCatalog = (normalized, report) => {
 };
 
 // src/schema/postPurchaseSubscriptionProduct.ts
-var import_zod54 = require("zod");
+var import_zod55 = require("zod");
 
 // src/schema/postPurchaseProduct.ts
-var import_zod53 = require("zod");
+var import_zod54 = require("zod");
 
 // src/schema/postPurchaseProductDisplay.ts
-var import_zod51 = require("zod");
+var import_zod52 = require("zod");
 
 // src/schema/postPurchaseProductGallery.ts
 var import_zod50 = require("zod");
@@ -5981,17 +5981,44 @@ var PostPurchaseProductGallery = import_zod50.z.object({
   selectedImageId: import_zod50.z.number().int().positive().optional()
 });
 
+// src/schema/postPurchaseProductReviews.ts
+var import_zod51 = require("zod");
+var decimal = import_zod51.z.union([
+  import_zod51.z.number(),
+  import_zod51.z.string().regex(/^\d+(?:\.\d+)?$/).transform(Number)
+]);
+var PostPurchaseCommonReviewRating = import_zod51.z.object({ value: decimal.pipe(import_zod51.z.number().min(0).max(5)) });
+var PostPurchaseKlaviyoReviewRating = PostPurchaseCommonReviewRating.extend({
+  // Legacy validates key presence, then displays the raw value on five stars without rescaling.
+  scale_max: import_zod51.z.unknown().nonoptional(),
+  scale_min: import_zod51.z.unknown().nonoptional()
+});
+var PostPurchaseReviewCount = import_zod51.z.string().regex(/^\d+(?:\.\d+)?$/).transform(Number).pipe(import_zod51.z.number().int().nonnegative());
+var PostPurchaseReviewStyles = PostPurchaseSettings.shape.styles.unwrap().extend({
+  strokeWidth: decimal.pipe(import_zod51.z.number().nonnegative()).default(1)
+}).prefault({});
+var PostPurchaseProductReviews = import_zod51.z.object({
+  color: import_zod51.z.string(),
+  rating: import_zod51.z.number().positive().max(5),
+  reviewCount: import_zod51.z.number().int().nonnegative(),
+  reviewsPlural: import_zod51.z.string(),
+  reviewsSingular: import_zod51.z.string(),
+  size: import_zod51.z.enum(["small", "medium", "large"]),
+  strokeColor: import_zod51.z.string(),
+  strokeWidth: import_zod51.z.number().nonnegative()
+});
+
 // src/schema/postPurchaseProductDisplay.ts
 var language = PostPurchaseSettings.shape.language;
-var PostPurchasePrimaryImageSource = import_zod51.z.string().default(
+var PostPurchasePrimaryImageSource = import_zod52.z.string().default(
   "https://cdn.shopify.com/shopifycloud/shopify/assets/no-image-2048-5e88c1b20e087fb7bbe9a3771824e743c244f437e4f8ba93bbf7b11b53f7824c.gif"
 );
-var PostPurchaseProductDisplay = import_zod51.z.object({
+var PostPurchaseProductDisplay = import_zod52.z.object({
   descriptionDocument: TiptapDocument.optional(),
   discountedFrom: PostPurchaseSettings.shape.discountedFrom,
   gallery: PostPurchaseProductGallery.optional(),
   language: language.pick({ description: true, descriptionEnabled: true }),
-  primaryImage: import_zod51.z.object({ description: import_zod51.z.string(), source: import_zod51.z.string() }),
+  primaryImage: import_zod52.z.object({ description: import_zod52.z.string(), source: import_zod52.z.string() }),
   productOptions: PostPurchaseSettings.shape.productOptions.pick({
     showDeclineAll: true,
     showShipping: true,
@@ -6001,18 +6028,19 @@ var PostPurchaseProductDisplay = import_zod51.z.object({
     showVariantSelectors: true
   }),
   responseDescription: language.shape.description,
+  reviews: PostPurchaseProductReviews.nullable().default(null),
   shouldShowSavingText: PostPurchaseSettings.shape.discount.shape.shouldShowSavingText
 });
 
 // src/schema/postPurchaseSubscription.ts
-var import_zod52 = require("zod");
-var PostPurchaseSubscriptionTerms = import_zod52.z.object({
+var import_zod53 = require("zod");
+var PostPurchaseSubscriptionTerms = import_zod53.z.object({
   adjustment: PostPurchasePlanAdjustment.optional(),
-  initialShippingPrice: import_zod52.z.number().nonnegative(),
-  intervalLabel: import_zod52.z.string().min(1),
-  name: import_zod52.z.string().min(1),
-  recurringShippingPrice: import_zod52.z.number().nonnegative(),
-  shippingOption: import_zod52.z.object({ presentmentTitle: import_zod52.z.string(), title: import_zod52.z.string() })
+  initialShippingPrice: import_zod53.z.number().nonnegative(),
+  intervalLabel: import_zod53.z.string().min(1),
+  name: import_zod53.z.string().min(1),
+  recurringShippingPrice: import_zod53.z.number().nonnegative(),
+  shippingOption: import_zod53.z.object({ presentmentTitle: import_zod53.z.string(), title: import_zod53.z.string() })
 });
 
 // src/schema/postPurchaseProduct.ts
@@ -6022,51 +6050,51 @@ var PostPurchaseVariant = OfferProduct.shape.variants.element.pick({ id: true, t
   id: PostPurchaseVariantId,
   price: PostPurchaseAmount
 });
-var PreparedPostPurchaseProduct = import_zod53.z.object({
+var PreparedPostPurchaseProduct = import_zod54.z.object({
   display: PostPurchaseProductDisplay,
-  labels: import_zod53.z.object({
+  labels: import_zod54.z.object({
     declineAll: global.declineAll,
-    free: import_zod53.z.string(),
-    payNow: import_zod53.z.string(),
-    quantity: import_zod53.z.string(),
+    free: import_zod54.z.string(),
+    payNow: import_zod54.z.string(),
+    quantity: import_zod54.z.string(),
     recurringShipping: global.recurringShipping,
     recurringSubtotal: global.recurringSubtotal,
-    save: import_zod53.z.string(),
-    shipping: import_zod53.z.string(),
-    subtotal: import_zod53.z.string(),
-    taxes: import_zod53.z.string(),
-    total: import_zod53.z.string()
+    save: import_zod54.z.string(),
+    shipping: import_zod54.z.string(),
+    subtotal: import_zod54.z.string(),
+    taxes: import_zod54.z.string(),
+    total: import_zod54.z.string()
   }),
   product: OfferProduct.pick({ description: true, id: true, image: true, title: true }).extend({
     description: OfferProduct.shape.description.nullable(),
     id: PostPurchaseProductId,
     variant: PostPurchaseVariant
   }),
-  selection: import_zod53.z.object({
+  selection: import_zod54.z.object({
     productId: PostPurchaseProductId,
-    quantity: import_zod53.z.number().int().positive(),
-    sellingPlanId: import_zod53.z.number().int().positive().optional(),
+    quantity: import_zod54.z.number().int().positive(),
+    sellingPlanId: import_zod54.z.number().int().positive().optional(),
     variantId: PostPurchaseVariantId
   }),
-  status: import_zod53.z.literal("prepared"),
-  terms: import_zod53.z.object({
+  status: import_zod54.z.literal("prepared"),
+  terms: import_zod54.z.object({
     discount: PostPurchaseDiscount,
-    shipping: import_zod53.z.object({
-      amount: import_zod53.z.number().nonnegative(),
-      title: import_zod53.z.string(),
-      type: import_zod53.z.enum(["free", "fixed_amount"])
+    shipping: import_zod54.z.object({
+      amount: import_zod54.z.number().nonnegative(),
+      title: import_zod54.z.string(),
+      type: import_zod54.z.enum(["free", "fixed_amount"])
     }),
     subscription: PostPurchaseSubscriptionTerms.optional()
   })
 });
-var PostPurchasePreparation = import_zod53.z.discriminatedUnion("status", [
+var PostPurchasePreparation = import_zod54.z.discriminatedUnion("status", [
   PreparedPostPurchaseProduct,
-  import_zod53.z.object({ reason: import_zod53.z.string(), status: import_zod53.z.literal("unsupported") })
+  import_zod54.z.object({ reason: import_zod54.z.string(), status: import_zod54.z.literal("unsupported") })
 ]);
 
 // src/schema/postPurchaseSubscriptionProduct.ts
 var PreparedPostPurchaseSubscription = PreparedPostPurchaseProduct.extend({
-  selection: PreparedPostPurchaseProduct.shape.selection.extend({ sellingPlanId: import_zod54.z.number().int().positive() }),
+  selection: PreparedPostPurchaseProduct.shape.selection.extend({ sellingPlanId: import_zod55.z.number().int().positive() }),
   terms: PreparedPostPurchaseProduct.shape.terms.extend({
     subscription: PostPurchaseSubscriptionTerms
   }).refine(
@@ -6108,7 +6136,7 @@ var subscriptionUnavailable = (normalized, plan, allowCollection, quantity2) =>
 };
 
 // src/server/postPurchaseProductDisplay.ts
-var import_zod56 = require("zod");
+var import_zod57 = require("zod");
 
 // src/server/postPurchasePrimaryImage.ts
 var postPurchasePrimaryImage = (product) => {
@@ -6130,7 +6158,7 @@ var postPurchaseProductGallery = (product, limit) => ({
 });
 
 // src/transforms/postPurchase/convertDescriptionRte.ts
-var import_zod55 = require("zod");
+var import_zod56 = require("zod");
 var alignments = { center: "center", left: "start", right: "end" };
 var colors = ["critical", "subdued", "success", "warning"];
 var sizes2 = ["extraSmall", "small", "medium", "large", "extraLarge"];
@@ -6142,19 +6170,19 @@ var spacings2 = {
   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)
+var Block = import_zod56.z.object({
+  attrs: import_zod56.z.object({ alignment: import_zod56.z.enum(["left", "center", "right"]).optional().catch(void 0) }).catch({}),
+  content: import_zod56.z.array(import_zod56.z.unknown()).catch([]),
+  type: import_zod56.z.literal("ShopifyTextBlock")
+});
+var Run = import_zod56.z.object({ marks: import_zod56.z.array(import_zod56.z.unknown()).catch([]), text: import_zod56.z.string().min(1), type: import_zod56.z.literal("text") });
+var Inline = import_zod56.z.object({
+  attrs: import_zod56.z.object({
+    color: import_zod56.z.enum(colors).optional().catch(void 0),
+    emphasis: import_zod56.z.array(import_zod56.z.unknown()).catch([]),
+    size: import_zod56.z.enum(sizes2).optional().catch(void 0)
   }),
-  type: import_zod55.z.literal("ShopifyTextInline")
+  type: import_zod56.z.literal("ShopifyTextInline")
 });
 var marks = (raw) => {
   const found = raw.map((mark) => Inline.safeParse(mark)).find(({ success }) => success)?.data;
@@ -6187,7 +6215,7 @@ var convertDescriptionRte = (rte, spacing) => TiptapDocument.parse({
 });
 
 // src/server/postPurchaseProductDisplay.ts
-var ResponseLanguage = import_zod56.z.object({ description: PostPurchaseProductDisplay.shape.responseDescription }).default({ description: "" });
+var ResponseLanguage = import_zod57.z.object({ description: PostPurchaseProductDisplay.shape.responseDescription }).default({ description: "" });
 var projectPostPurchaseProductDisplay = (effective, metadata, product) => PostPurchaseProductDisplay.parse({
   descriptionDocument: effective.language.descriptionRte && convertDescriptionRte(effective.language.descriptionRte, effective.language.descriptionSpacing),
   discountedFrom: effective.discountedFrom,
@@ -6199,12 +6227,142 @@ var projectPostPurchaseProductDisplay = (effective, metadata, product) => PostPu
   shouldShowSavingText: effective.discount.shouldShowSavingText
 });
 
+// src/server/postPurchaseReviewData.ts
+var import_zod61 = require("zod");
+
+// src/server/postPurchaseJudgeMeReviews.ts
+var import_zod58 = require("zod");
+var readJudgeMeReviews = (find) => {
+  const field = find("judgeme", "badge");
+  if (!field) return null;
+  const html = import_zod58.z.string().parse(field.value);
+  const rating = html.match(/data-average-rating=['"](\d+(?:\.\d+)?)['"]/);
+  const count = html.match(/data-number-of-reviews=['"](\d+)['"]/);
+  if (!rating || !count) throw new Error("Unreadable Judge.me attributes");
+  return {
+    rating: PostPurchaseCommonReviewRating.parse({ value: rating[1] }).value,
+    reviewCount: PostPurchaseReviewCount.parse(count[1])
+  };
+};
+
+// src/server/postPurchaseOkendoReviews.ts
+var import_zod59 = require("zod");
+var Summary = import_zod59.z.object({
+  reviewAverageValue: PostPurchaseCommonReviewRating.shape.value,
+  reviewCount: import_zod59.z.union([PostPurchaseProductReviews.shape.reviewCount, PostPurchaseReviewCount])
+});
+var readOkendoReviews = (find) => {
+  const field = find("okendo", "summaryData");
+  if (!field) return null;
+  const summary = Summary.parse(JSON.parse(import_zod59.z.string().parse(field.value)));
+  return { rating: summary.reviewAverageValue, reviewCount: summary.reviewCount };
+};
+
+// src/server/postPurchaseScalarReviews.ts
+var import_zod60 = require("zod");
+var readScalarReviews = (find, namespace, ratingKey, countKey) => {
+  const rating = find(namespace, ratingKey);
+  const count = find(namespace, countKey);
+  if (!rating || !count) return null;
+  return {
+    rating: PostPurchaseCommonReviewRating.parse({ value: import_zod60.z.string().parse(rating.value) }).value,
+    reviewCount: PostPurchaseReviewCount.parse(count.value)
+  };
+};
+
+// src/server/postPurchaseReviewData.ts
+var readPostPurchaseReviewData = (provider, find) => {
+  if (provider === "yotpo") return readScalarReviews(find, "yotpo", "reviews_average", "reviews_count");
+  if (provider === "stamped") return readScalarReviews(find, "stamped", "reviews_average", "reviews_count");
+  if (provider === "judgeme") return readJudgeMeReviews(find);
+  if (provider === "okendo") return readOkendoReviews(find);
+  if (provider === "opinew") return readScalarReviews(find, "opinew_metafields", "reviews_average", "reviews_count");
+  if (provider === "reviewsio") return readScalarReviews(find, "reviewscouk", "rating", "total");
+  if (provider === "loox") return readScalarReviews(find, "loox", "avg_rating", "num_reviews");
+  if (provider === "junip") return readScalarReviews(find, "junip", "rating_average", "rating_count");
+  const rating = find("reviews", "rating");
+  const count = find("reviews", "rating_count");
+  if (!rating || !count) return null;
+  return {
+    rating: PostPurchaseKlaviyoReviewRating.parse(JSON.parse(import_zod61.z.string().parse(rating.value))).value,
+    reviewCount: PostPurchaseReviewCount.parse(count.value)
+  };
+};
+
+// src/server/postPurchaseReviewFields.ts
+var import_zod62 = require("zod");
+var Field = import_zod62.z.object({ key: import_zod62.z.string(), namespace: import_zod62.z.string(), value: import_zod62.z.unknown().optional() });
+var reviewFields = (raw) => {
+  const fields4 = import_zod62.z.array(import_zod62.z.unknown()).parse(raw).flatMap((field) => {
+    const parsed = Field.safeParse(field);
+    return parsed.success ? [parsed.data] : [];
+  });
+  return (namespace, key) => fields4.find((field) => field.namespace === namespace && field.key === key);
+};
+
+// src/server/postPurchaseReviewProvider.ts
+var import_zod63 = require("zod");
+var IntegrationInput = import_zod63.z.record(import_zod63.z.string(), import_zod63.z.unknown()).prefault({});
+var precedence = [
+  "klaviyo",
+  "judgeme",
+  "junip",
+  "loox",
+  "okendo",
+  "opinew",
+  "reviewsio",
+  "stamped",
+  "yotpo"
+];
+var ReviewsIoFlag = import_zod63.z.preprocess((value) => {
+  if (typeof value === "string") {
+    const flag = value.toLowerCase();
+    if (flag === "true" || flag === "yes") return true;
+    if (flag === "false" || flag === "no") return false;
+  }
+  return value;
+}, PostPurchaseSettings.shape.integrations.shape.reviewsio);
+var selectPostPurchaseReviewProvider = (raw) => {
+  const integrations = IntegrationInput.parse(raw);
+  for (const provider of precedence) {
+    const schema = provider === "reviewsio" ? ReviewsIoFlag : PostPurchaseSettings.shape.integrations.shape[provider];
+    if (schema.parse(integrations[provider])) return provider;
+  }
+  return null;
+};
+
+// src/server/postPurchaseReviews.ts
+var projectPostPurchaseReviews = (settings, metafields, report) => {
+  try {
+    const provider = selectPostPurchaseReviewProvider(settings.integrations);
+    if (!provider || metafields == null) return null;
+    const data = readPostPurchaseReviewData(provider, reviewFields(metafields));
+    if (data === null || data.rating === 0) return null;
+    const styles2 = PostPurchaseReviewStyles.parse(settings.styles);
+    return PostPurchaseProductReviews.parse({
+      color: styles2.starColor,
+      ...data,
+      reviewsPlural: settings.language.global.reviewsPlural,
+      reviewsSingular: settings.language.global.reviewsSingular,
+      size: styles2.starSize,
+      strokeColor: styles2.starStrokeColor,
+      strokeWidth: styles2.strokeWidth
+    });
+  } catch {
+    report?.({ detail: "Unreadable post-purchase reviews", kind: "product" });
+    return null;
+  }
+};
+
 // src/server/projectPostPurchaseProduct.ts
-var projectPostPurchaseProduct = ({ data, effective, metadata, original }, selectedQuantity) => {
+var projectPostPurchaseProduct = ({ data, effective, metadata, original }, report, selectedQuantity) => {
   const product = data[0];
   const variant2 = product.variants[0];
   return {
-    display: projectPostPurchaseProductDisplay(effective, metadata, product),
+    display: {
+      ...projectPostPurchaseProductDisplay(effective, metadata, product),
+      reviews: projectPostPurchaseReviews(effective, product.metafields, report)
+    },
     labels: effective.language.global,
     product: { ...product, variant: variant2 },
     selection: {
@@ -6221,7 +6379,7 @@ var prepareNormalizedSubscription = (normalized, report, plan, quantity2, allowC
   const reason = subscriptionUnavailable(normalized, plan, allowCollection, quantity2);
   if (reason) return { reason, status: "unsupported" };
   const { effective } = normalized;
-  const projected = projectPostPurchaseProduct(normalized, quantity2);
+  const projected = projectPostPurchaseProduct(normalized, report, quantity2);
   const { discount, shipping } = PostPurchaseSubscriptionSettings.parse(effective.subscription);
   const shippingPrice = shipping.type === "free" ? 0 : shipping.amount;
   return PreparedPostPurchaseSubscription.parse({
@@ -6279,7 +6437,7 @@ var prepareNormalizedProduct = (normalized, report, quantity2, allowCollection =
   if (reason) return { reason, status: "unsupported" };
   const { effective } = normalized;
   return PreparedPostPurchaseProduct.parse({
-    ...projectPostPurchaseProduct(normalized, quantity2),
+    ...projectPostPurchaseProduct(normalized, report, quantity2),
     status: "prepared",
     terms: {
       discount: { ...effective.discount, title: effective.language.global.save },
@@ -6290,45 +6448,45 @@ var prepareNormalizedProduct = (normalized, report, quantity2, allowCollection =
 var preparePostPurchaseProduct = (settings, response, report) => prepareNormalizedProduct(normalizePostPurchaseProduct(settings, response), report);
 
 // src/schema/postPurchaseProductView.ts
-var import_zod60 = require("zod");
+var import_zod67 = 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 import_zod64 = require("zod");
+var PostPurchaseChoice = import_zod64.z.discriminatedUnion("mode", [
+  import_zod64.z.object({ mode: import_zod64.z.literal("one-time") }).strict(),
+  import_zod64.z.object({ mode: import_zod64.z.literal("subscription"), sellingPlanId: PostPurchasePlanOption.shape.id }).strict()
 ]);
-var PostPurchaseOptions = import_zod57.z.object({
+var PostPurchaseOptions = import_zod64.z.object({
   defaultChoice: PostPurchaseChoice,
-  modes: import_zod57.z.array(import_zod57.z.enum(["one-time", "subscription"])).min(1).max(2),
+  modes: import_zod64.z.array(import_zod64.z.enum(["one-time", "subscription"])).min(1).max(2),
   selector: PostPurchaseSettings.shape.productTypeSelector
 });
 
 // src/schema/postPurchaseGroupCatalog.ts
-var import_zod59 = require("zod");
+var import_zod66 = require("zod");
 
 // src/schema/postPurchaseVariantCatalog.ts
-var import_zod58 = require("zod");
-var PostPurchaseVariantSelector = import_zod58.z.object({ variantId: PostPurchaseVariantId }).strict();
+var import_zod65 = require("zod");
+var PostPurchaseVariantSelector = import_zod65.z.object({ variantId: PostPurchaseVariantId }).strict();
 var PostPurchaseVariantOption = OfferProduct.shape.options.element.extend({
-  id: import_zod58.z.number().int().positive(),
-  position: import_zod58.z.number().int().min(1).max(3)
+  id: import_zod65.z.number().int().positive(),
+  position: import_zod65.z.number().int().min(1).max(3)
 });
 var PostPurchaseVariantValues = OfferProduct.shape.variants.element.pick({
   option1: true,
   option2: true,
   option3: true
 });
-var PostPurchaseVariantCatalog = import_zod58.z.object({
+var PostPurchaseVariantCatalog = import_zod65.z.object({
   displayMode: PostPurchaseSettings.shape.productOptions.shape.variantSelectorDisplayMode,
-  options: import_zod58.z.array(PostPurchaseVariantOption),
+  options: import_zod65.z.array(PostPurchaseVariantOption),
   productId: PostPurchaseProductId,
   showSelectors: PostPurchaseSettings.shape.productOptions.shape.showVariantSelectors,
-  variants: import_zod58.z.array(
+  variants: import_zod65.z.array(
     PostPurchaseVariantValues.partial().extend({
-      available: import_zod58.z.boolean(),
+      available: import_zod65.z.boolean(),
       id: PostPurchaseVariantId,
-      imageId: import_zod58.z.number().int().nonnegative().nullish(),
+      imageId: import_zod65.z.number().int().nonnegative().nullish(),
       title: OfferProduct.shape.variants.element.shape.title
     })
   )
@@ -6342,23 +6500,23 @@ var PostPurchaseGroupDescription = source.pick({ description: true, id: true, im
   image: source.shape.image.default(null),
   options: PostPurchaseVariantCatalog.shape.options.default([])
 });
-var PostPurchaseGroupCatalog = import_zod59.z.object({
+var PostPurchaseGroupCatalog = import_zod66.z.object({
   memberProductId: productId,
-  options: import_zod59.z.array(import_zod59.z.object({ productId, title: import_zod59.z.string(), variantCatalog: PostPurchaseVariantCatalog }))
+  options: import_zod66.z.array(import_zod66.z.object({ productId, title: import_zod66.z.string(), variantCatalog: PostPurchaseVariantCatalog }))
 });
-var PostPurchaseGroupSelection = import_zod59.z.object({
+var PostPurchaseGroupSelection = import_zod66.z.object({
   memberProductId: productId,
   productId
 });
 
 // src/schema/postPurchaseProductView.ts
-var PostPurchaseProductView = import_zod60.z.union([
-  import_zod60.z.object({
+var PostPurchaseProductView = import_zod67.z.union([
+  import_zod67.z.object({
     groupCatalog: PostPurchaseGroupCatalog.optional(),
     initialVariant: PostPurchaseVariantSelector.optional(),
     planCatalog: PostPurchasePlanCatalog.nullable().optional(),
     preparation: PreparedPostPurchaseProduct.extend({
-      display: PreparedPostPurchaseProduct.shape.display.extend({ description: import_zod60.z.string().nullable() }).refine(
+      display: PreparedPostPurchaseProduct.shape.display.extend({ description: import_zod67.z.string().nullable() }).refine(
         ({ description, descriptionDocument }) => description === null === (descriptionDocument !== void 0),
         "Exactly one of the plain and rich descriptions is shown"
       )
@@ -6367,24 +6525,24 @@ var PostPurchaseProductView = import_zod60.z.union([
     sections: CABRootSection,
     variantCatalog: PostPurchaseVariantCatalog.optional()
   }),
-  import_zod60.z.object({
+  import_zod67.z.object({
     groupCatalog: PostPurchaseGroupCatalog.optional(),
     initialVariant: PostPurchaseVariantSelector.optional(),
     planCatalog: PostPurchasePlanCatalog.nullable().optional(),
     preparation: PostPurchasePreparation.options[1],
     purchaseOptions: PostPurchaseOptions.optional(),
-    sections: import_zod60.z.null(),
+    sections: import_zod67.z.null(),
     variantCatalog: PostPurchaseVariantCatalog.optional()
   })
 ]);
 
 // src/server/postPurchaseOfferCopy.ts
-var import_zod61 = require("zod");
-var Copy = import_zod61.z.object({
+var import_zod68 = require("zod");
+var Copy = import_zod68.z.object({
   superTitle: CalloutBannerBlock.shape.settings.shape.superTitle.unwrap().optional().catch(void 0),
   title: CalloutBannerBlock.shape.settings.shape.title.unwrap().optional().catch(void 0)
 });
-var Callout = import_zod61.z.object({ settings: import_zod61.z.record(import_zod61.z.string(), import_zod61.z.unknown()), type: import_zod61.z.literal("callout_banner") });
+var Callout = import_zod68.z.object({ settings: import_zod68.z.record(import_zod68.z.string(), import_zod68.z.unknown()), type: import_zod68.z.literal("callout_banner") });
 var postPurchaseOfferCopy = (blocks, metadata) => {
   const copy = Copy.safeParse(metadata.widget.language);
   if (!blocks || !copy.success) return blocks;
@@ -6483,28 +6641,28 @@ var preparePostPurchaseAdmissionView = (widgetId, settings, response, report, ch
 };
 
 // src/schema/postPurchaseProductCollectionView.ts
-var import_zod62 = require("zod");
-var PostPurchaseProductCollectionView = import_zod62.z.object({
-  members: import_zod62.z.array(
-    import_zod62.z.object({
+var import_zod69 = require("zod");
+var PostPurchaseProductCollectionView = import_zod69.z.object({
+  members: import_zod69.z.array(
+    import_zod69.z.object({
       productId: PostPurchaseProductId,
-      productIndex: import_zod62.z.number().int().nonnegative(),
+      productIndex: import_zod69.z.number().int().nonnegative(),
       view: PostPurchaseProductView
     })
   )
 });
-var PostPurchaseCollectionChoice = import_zod62.z.object({
+var PostPurchaseCollectionChoice = import_zod69.z.object({
   choice: PostPurchaseChoice.optional(),
   productId: PostPurchaseProductId,
   variantId: PostPurchaseVariantSelector.shape.variantId.optional()
 }).strict();
-var PostPurchaseExcludedProductIds = import_zod62.z.array(PostPurchaseProductId).default([]);
+var PostPurchaseExcludedProductIds = import_zod69.z.array(PostPurchaseProductId).default([]);
 
 // src/server/normalizePostPurchaseCollection.ts
-var import_zod63 = require("zod");
+var import_zod70 = require("zod");
 var normalizePostPurchaseCollection = (settings, response, excludedProductIds) => {
   const normalized = normalizePostPurchaseProduct(settings, response);
-  const limit = import_zod63.z.number().int().positive();
+  const limit = import_zod70.z.number().int().positive();
   limit.parse(normalized.original.productLimit);
   const prefix = normalized.data.slice(0, limit.parse(normalized.effective.productLimit));
   if (new Set(prefix.map(({ id }) => id)).size !== prefix.length)
@@ -6548,13 +6706,13 @@ var projectPostPurchaseVariantCatalog = (product, settings) => {
 };
 
 // src/schema/postPurchaseQuantity.ts
-var import_zod64 = require("zod");
+var import_zod71 = require("zod");
 var quantity = PreparedPostPurchaseProduct.shape.selection.shape.quantity;
 var PostPurchaseQuantityChoice = PostPurchaseCollectionChoice.extend({ quantity: quantity.optional() });
 var PostPurchaseQuantityPolicy = PostPurchaseSettings.shape.quantityInputs.omit({ defaultQuantity: true }).extend({
   initialQuantity: quantity,
   maxValue: quantity,
-  minValue: import_zod64.z.literal(0).transform(() => 1).or(quantity)
+  minValue: import_zod71.z.literal(0).transform(() => 1).or(quantity)
 }).refine(({ maxValue, minValue }) => minValue <= maxValue, "Quantity bounds are reversed");
 
 // src/server/readPostPurchaseQuantity.ts
@@ -6585,39 +6743,39 @@ var readPostPurchaseQuantity = ({
 };
 
 // src/schema/postPurchaseVariantDefault.ts
-var import_zod65 = require("zod");
+var import_zod72 = 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()
+  inventoryManagement: import_zod72.z.string().nullable(),
+  inventoryPolicy: import_zod72.z.string(),
+  inventoryQuantity: import_zod72.z.number()
 });
-var options = import_zod65.z.array(PostPurchaseVariantOption.pick({ name: true, values: true }));
-var PostPurchaseVariantDefaultProduct = import_zod65.z.object({
+var options = import_zod72.z.array(PostPurchaseVariantOption.pick({ name: true, values: true }));
+var PostPurchaseVariantDefaultProduct = import_zod72.z.object({
   id: PostPurchaseProductId,
   options,
   selectedVariant: variant.optional(),
-  variants: import_zod65.z.array(variant)
+  variants: import_zod72.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 PostPurchaseOrderAttributes = import_zod72.z.record(import_zod72.z.string(), import_zod72.z.array(import_zod72.z.string())).default({});
+var PostPurchaseOriginalVariants = import_zod72.z.array(
+  import_zod72.z.object({ productId: PostPurchaseProductId, variantId: PostPurchaseVariantId })
 );
-var PostPurchaseAttributeProducts = import_zod65.z.array(
-  import_zod65.z.object({ id: PostPurchaseProductId, options, variants: import_zod65.z.array(values.extend({ id: PostPurchaseVariantId })) })
+var PostPurchaseAttributeProducts = import_zod72.z.array(
+  import_zod72.z.object({ id: PostPurchaseProductId, options, variants: import_zod72.z.array(values.extend({ id: PostPurchaseVariantId })) })
 );
 
 // src/schema/postPurchaseVariantDefaultContext.ts
-var import_zod66 = require("zod");
-var PostPurchaseVariantDefaultContext = import_zod66.z.object({
-  enrichedLineItems: import_zod66.z.unknown().optional(),
+var import_zod73 = require("zod");
+var PostPurchaseVariantDefaultContext = import_zod73.z.object({
+  enrichedLineItems: import_zod73.z.unknown().optional(),
   originalVariants: PostPurchaseOriginalVariants
 });
 
@@ -6960,22 +7118,22 @@ var preparePostPurchaseCollectionView = (widgetId, settings, response, report, r
 };
 
 // src/schema/postPurchaseOfferEligibility.ts
-var import_zod67 = require("zod");
+var import_zod74 = require("zod");
 var selection2 = PreparedPostPurchaseProduct.shape.selection;
-var PostPurchaseOfferSkipReason = import_zod67.z.enum(["empty", "no-eligible-subscription"]);
-var PostPurchaseOfferEligibilityContext = import_zod67.z.object({
+var PostPurchaseOfferSkipReason = import_zod74.z.enum(["empty", "no-eligible-subscription"]);
+var PostPurchaseOfferEligibilityContext = import_zod74.z.object({
   excludedProductIds: PostPurchaseExcludedProductIds,
-  originalLineItems: import_zod67.z.array(selection2.pick({ productId: true, sellingPlanId: true, variantId: true }))
+  originalLineItems: import_zod74.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() })
+var PostPurchaseOfferEligibility = import_zod74.z.discriminatedUnion("status", [
+  import_zod74.z.object({
+    members: import_zod74.z.array(
+      import_zod74.z.object({ productId: selection2.shape.productId, productIndex: import_zod74.z.number().int().nonnegative() })
     ),
-    status: import_zod67.z.literal("retain")
+    status: import_zod74.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") })
+  import_zod74.z.object({ reason: PostPurchaseOfferSkipReason, status: import_zod74.z.literal("skip") }),
+  import_zod74.z.object({ reason: import_zod74.z.literal("eligible-upgrade").optional(), status: import_zod74.z.literal("unavailable") })
 ]);
 
 // src/server/postPurchaseMemberEligibility.ts
@@ -7069,12 +7227,12 @@ var preparePostPurchaseGroupDeclineDisplay = (settings, response, requested, exc
 
 // src/server/preparePostPurchaseOfferPresentation.ts
 var import_compat7 = require("es-toolkit/compat");
-var import_zod69 = require("zod");
+var import_zod76 = require("zod");
 
 // src/schema/postPurchaseOfferPresentation.ts
-var import_zod68 = require("zod");
+var import_zod75 = require("zod");
 var language2 = PostPurchaseSettings.shape.language.shape.global.unwrap().unwrap();
-var PostPurchaseOfferPresentation = import_zod68.z.strictObject({
+var PostPurchaseOfferPresentation = import_zod75.z.strictObject({
   labels: language2.pick({ declineAll: true, declineThisOffer: true }),
   layout: PostPurchaseSettings.shape.offersLayout,
   sections: CABRootSection.nullable(),
@@ -7083,7 +7241,7 @@ var PostPurchaseOfferPresentation = import_zod68.z.strictObject({
 
 // 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()
+  blocks: import_zod76.z.array(import_zod76.z.unknown()).optional()
 });
 var preparePostPurchaseOfferPresentation = (widgetId, settings, response, report) => {
   const { metadata } = PostPurchaseProductSource.pick({ metadata: true }).parse(deepCamelCase(response));
@@ -7243,7 +7401,7 @@ var postAnalyticsEvents = async (input, ctx) => {
 };
 
 // src/server/requestSchemas.ts
-var import_zod70 = require("zod");
+var import_zod77 = require("zod");
 var REQUEST_BOUNDS = {
   /** Cart-level attributes per cart. */
   CART_ATTRIBUTES_MAX: 100,
@@ -7274,42 +7432,42 @@ var REQUEST_BOUNDS = {
   /** Rich ads transaction lines — the engine's ads contract. */
   TRANSACTION_ITEMS_MAX: 50
 };
-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 KeyValue = import_zod77.z.object({
+  key: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX),
+  value: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_VALUE_MAX).optional()
 });
-var CartLineInputSchema = import_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 CartLineInputSchema = import_zod77.z.object({
+  productId: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  properties: import_zod77.z.array(KeyValue).max(REQUEST_BOUNDS.LINE_PROPERTIES_MAX).optional(),
+  quantity: import_zod77.z.number(),
+  subscriptionId: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  variantId: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX)
 });
-var CartInputSchema = import_zod70.z.object({
-  attributes: import_zod70.z.array(KeyValue).max(REQUEST_BOUNDS.CART_ATTRIBUTES_MAX).optional(),
+var CartInputSchema = import_zod77.z.object({
+  attributes: import_zod77.z.array(KeyValue).max(REQUEST_BOUNDS.CART_ATTRIBUTES_MAX).optional(),
   /**
    * Presentment-per-shop-currency FX rate (buyer price ÷ shop price, e.g. `1.35` for a USD shop
    * selling in CAD). Money rule thresholds are authored in SHOP currency, so the engine subtotal is
    * divided by this before evaluation. Omit (or send 1) when the cart is already in the shop's currency.
    */
-  currencyRate: import_zod70.z.number().optional(),
+  currencyRate: import_zod77.z.number().optional(),
   /** Applied discount codes; the engine evaluates `discount_code` rules against them (sent as `[{code}]`). */
-  discountCodes: import_zod70.z.array(import_zod70.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX)).max(REQUEST_BOUNDS.DISCOUNT_CODES_MAX).optional(),
+  discountCodes: import_zod77.z.array(import_zod77.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX)).max(REQUEST_BOUNDS.DISCOUNT_CODES_MAX).optional(),
   /** Presentment cents of cart-level discount allocations, subtracted from `subtotal` for the engine. */
-  discountTotal: import_zod70.z.number().optional(),
-  items: import_zod70.z.array(CartLineInputSchema).max(REQUEST_BOUNDS.CART_ITEMS_MAX),
+  discountTotal: import_zod77.z.number().optional(),
+  items: import_zod77.z.array(CartLineInputSchema).max(REQUEST_BOUNDS.CART_ITEMS_MAX),
   /** Presentment subtotal in cents. */
-  subtotal: import_zod70.z.number()
+  subtotal: import_zod77.z.number()
 });
-var UserConfigInputSchema = import_zod70.z.object({ shop: import_zod70.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX) });
-var DataSourceInputSchema = import_zod70.z.object({
+var UserConfigInputSchema = import_zod77.z.object({ shop: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX) });
+var DataSourceInputSchema = import_zod77.z.object({
   cart: CartInputSchema,
   /**
    * Numeric Shopify company-location id when the buyer is a B2B session (`buyerIdentity.purchasingCompany`).
    * Present ⇒ the orchestrator filters results by the location's catalog via admin-api (REB-23713); the
    * client's country-context market check is bypassed for B2B (it false-negatives B2B-catalog products).
    */
-  companyLocationId: import_zod70.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  companyLocationId: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
   /**
    * Buyer's market country (ISO 3166-1 alpha-2) — forwarded to the engine as the `country_code` PARAM
    * when the shop's markets toggle is on (REB-21688; the sink was the `X-Country-Code` header under
@@ -7318,16 +7476,16 @@ var DataSourceInputSchema = import_zod70.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_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),
+  country: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).regex(/^[A-Za-z]{2}$/, "must be an ISO 3166-1 alpha-2 country code (e.g. CA)").transform((value) => value.toUpperCase()).optional(),
+  customerId: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  dataSourcePath: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX),
   /**
    * Engine `filter_inputs` override: `'no'` keeps in-cart (input) products in the results/rule
    * outputs — gift validation sends it so a gift's own product can appear in its answer. Omitted = the
    * engine's default filtering.
    */
-  filterInputs: import_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, {
+  filterInputs: import_zod77.z.enum(["no", "yes"]).optional(),
+  integrations: import_zod77.z.record(import_zod77.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX), import_zod77.z.boolean()).refine((record) => Object.keys(record).length <= REQUEST_BOUNDS.INTEGRATION_KEYS_MAX, {
     message: `Too many integration keys (max ${REQUEST_BOUNDS.INTEGRATION_KEYS_MAX})`
   }).optional(),
   /**
@@ -7340,31 +7498,31 @@ var DataSourceInputSchema = import_zod70.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_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(),
+  language: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).regex(/^[A-Za-z0-9-]+$/, "must be a single BCP-47 tag (e.g. fr-CA), not a q-value list").optional(),
+  limit: import_zod77.z.number().max(REQUEST_BOUNDS.LIMIT_MAX),
+  productType: import_zod77.z.enum(["both", "one-time", "subscription"]).optional(),
+  shop: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  visitorId: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
+});
+var GiftInputSchema = import_zod77.z.object({
+  cost: import_zod77.z.number(),
+  discounted: import_zod77.z.boolean(),
   /**
    * Which gift attribution the line carries (REB-24363). Defaults to `gwp` because a client that predates
    * the field only ever sent GWP lines — without the default an older extension's request would 422.
    */
-  kind: import_zod70.z.enum(GIFT_KINDS).default("gwp"),
-  lineId: import_zod70.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
-  productId: import_zod70.z.number(),
+  kind: import_zod77.z.enum(GIFT_KINDS).default("gwp"),
+  lineId: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  productId: import_zod77.z.number(),
   /**
    * The line's unit count (REB-24363) — the selectable-GWP verdict trims surplus units against milestone
    * capacity. The second deliberate default: a client predating the field sent only GWP lines, whose
    * verdict is whole-line, so a missing quantity reads as one unit rather than 422ing the older request.
    */
-  quantity: import_zod70.z.number().int().min(1).default(1),
-  widgetId: import_zod70.z.number()
+  quantity: import_zod77.z.number().int().min(1).default(1),
+  widgetId: import_zod77.z.number()
 });
-var GiftValidationInputSchema = import_zod70.z.object({
+var GiftValidationInputSchema = import_zod77.z.object({
   cart: CartInputSchema,
   /**
    * Buyer's market country — threaded into the per-widget data-source evaluations, which forward it to
@@ -7373,25 +7531,25 @@ var GiftValidationInputSchema = import_zod70.z.object({
    * turns markets off); regex-bound and uppercase-normalized for the same reasons as
    * `DataSourceInputSchema`'s `country`.
    */
-  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),
+  country: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).regex(/^[A-Za-z]{2}$/, "must be an ISO 3166-1 alpha-2 country code (e.g. CA)").transform((value) => value.toUpperCase()).optional(),
+  customerId: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  gifts: import_zod77.z.array(GiftInputSchema).max(REQUEST_BOUNDS.GIFTS_MAX),
   /**
    * Buyer's checkout language — threaded into the per-widget data-source evaluations, which normalize
    * and forward it as the engine `locale` param under the same markets-toggle gate (REB-21688). MUST be
    * a single BCP-47 tag, for the same reason as `DataSourceInputSchema`'s `language` above.
    */
-  language: import_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()
+  language: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).regex(/^[A-Za-z0-9-]+$/, "must be a single BCP-47 tag (e.g. fr-CA), not a q-value list").optional(),
+  shop: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  visitorId: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
 });
-var GiftAdjustmentSchema = import_zod70.z.object({
-  lineId: import_zod70.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
-  quantity: import_zod70.z.number().int().nonnegative()
+var GiftAdjustmentSchema = import_zod77.z.object({
+  lineId: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  quantity: import_zod77.z.number().int().nonnegative()
 });
-var GiftValidationResponseSchema = import_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(
+var GiftValidationResponseSchema = import_zod77.z.object({
+  adjust: import_zod77.z.array(GiftAdjustmentSchema).max(REQUEST_BOUNDS.GIFTS_MAX).default([]),
+  remove: import_zod77.z.array(import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX)).max(REQUEST_BOUNDS.GIFTS_MAX).refine(
     (remove) => new Set(remove).size === remove.length,
     "a line id may appear at most once in `remove`"
   )
@@ -7402,47 +7560,47 @@ var GiftValidationResponseSchema = import_zod70.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_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({
+var MonetizeTransactionItemSchema = import_zod77.z.object({
+  id: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  priceCents: import_zod77.z.number(),
+  quantity: import_zod77.z.number(),
+  title: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX),
+  type: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX)
+});
+var MonetizeInputSchema = import_zod77.z.object({
   cart: CartInputSchema,
   /** Client-minted render-beacon correlation id; forwarded to the ads engine as `client_request_id`. */
-  clientRequestId: import_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(),
+  clientRequestId: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  country: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  currency: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
   /** Ads-targeting identity/geo/locale fields (React parity); folded into the engine query verbatim. */
-  customerEmail: import_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(),
+  customerEmail: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
+  customerFirstName: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
+  customerId: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  customerLastName: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
+  language: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
   /** Buyer-facing order name (e.g. `#1001`) for the server-composed "Order … Confirmed" chrome line. */
-  orderName: import_zod70.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
+  orderName: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_TEXT_MAX).optional(),
   /** Ads surface label, forwarded verbatim; `customer_account` is measured/floored as its own surface (the account-area order list). */
-  placement: import_zod70.z.enum(["customer_account", "order_status", "thank_you_page"]),
+  placement: import_zod77.z.enum(["customer_account", "order_status", "thank_you_page"]),
   /** Privacy Policy footer href — the Monetize widget's `privacy_policy_url` setting (React parity). */
-  privacyPolicyUrl: import_zod70.z.string().max(REQUEST_BOUNDS.STRING_URL_MAX).optional(),
+  privacyPolicyUrl: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_URL_MAX).optional(),
   /** 30-min rolling session id (React parity); used for the ads `session_id`, else the visitor id. */
-  sessionId: import_zod70.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  shop: import_zod70.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  sessionId: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  shop: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
   /** Editor/QA indicator; OR-ed into the ads-engine `testing` flag so it stays out of billing/reporting. */
-  testing: import_zod70.z.boolean().optional(),
-  timezone: import_zod70.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  testing: import_zod77.z.boolean().optional(),
+  timezone: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
   /** Decorated (numeric) order id → the ads `transaction_id`. */
-  transactionId: import_zod70.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  transactionId: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
   /** Rich per-line ads items; capped at the engine's ads contract. Preferred over `cart.items`. */
-  transactionItems: import_zod70.z.array(MonetizeTransactionItemSchema).max(REQUEST_BOUNDS.TRANSACTION_ITEMS_MAX).optional(),
+  transactionItems: import_zod77.z.array(MonetizeTransactionItemSchema).max(REQUEST_BOUNDS.TRANSACTION_ITEMS_MAX).optional(),
   /** Order total in presentment cents (React prefers total over subtotal); else `cart.subtotal`. */
-  transactionTotal: import_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()
+  transactionTotal: import_zod77.z.number().optional(),
+  visitorId: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  zipCode: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
 });
-var WidgetSettingsInputSchema = import_zod70.z.object({
+var WidgetSettingsInputSchema = import_zod77.z.object({
   /**
    * Same domain as `CabShopConfig.cacheKey`, for the same reason: this side WINS the orchestrator's
    * `input.cacheKey ?? config.shop.cacheKey` (and an explicit value skips the config read entirely), so
@@ -7450,9 +7608,9 @@ var WidgetSettingsInputSchema = import_zod70.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_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(),
+  cacheKey: import_zod77.z.number().int().positive().optional().catch(void 0),
+  id: import_zod77.z.number(),
+  key: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
   /**
    * Monetize context for inline hydration: when present AND the widget converts to a Monetize marker,
    * the server fetches/composes the offer cards inside this same request (no second `/cab/monetize`
@@ -7461,34 +7619,34 @@ var WidgetSettingsInputSchema = import_zod70.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_zod70.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  shop: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
   /** Stable per-buyer id; when present, enables sticky server-side A/B variant selection. */
-  visitorId: import_zod70.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
+  visitorId: import_zod77.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 AnalyticsEventInputSchema = import_zod77.z.object({
+  name: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX),
+  properties: import_zod77.z.record(import_zod77.z.string().max(REQUEST_BOUNDS.STRING_KEY_MAX), import_zod77.z.unknown()).optional(),
+  sentAt: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
 });
-var AnalyticsSegmentsInputSchema = import_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 AnalyticsSegmentsInputSchema = import_zod77.z.object({
+  device: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional().catch(void 0),
+  source: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional().catch(void 0),
+  visitor: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional().catch(void 0)
 });
-var AnalyticsInputSchema = import_zod70.z.object({
+var AnalyticsInputSchema = import_zod77.z.object({
   /** Rebuy cart token (the `r_cart_token` cart attribute), when available — primary aggregation key. */
-  cartToken: import_zod70.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  cartToken: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
   /** Shopify checkout token, when available — drives cart/checkout aggregation downstream. */
-  checkoutToken: import_zod70.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
-  events: import_zod70.z.array(AnalyticsEventInputSchema).max(REQUEST_BOUNDS.EVENTS_MAX),
+  checkoutToken: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional(),
+  events: import_zod77.z.array(AnalyticsEventInputSchema).max(REQUEST_BOUNDS.EVENTS_MAX),
   /**
    * Request-scoped like the tokens: one visitor's segments apply to every event in the batch. The container
    * degrades too (`null` is a realistic wire artifact of `attributes ? {…} : null`), so the degrade rule is
    * total: nothing about `segments` can cost the envelope.
    */
   segments: AnalyticsSegmentsInputSchema.optional().catch(void 0),
-  shop: import_zod70.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
-  visitorId: import_zod70.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  shop: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
+  visitorId: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX),
   /** The widget id (smartBlockId) the events belong to. */
-  widgetId: import_zod70.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
+  widgetId: import_zod77.z.string().max(REQUEST_BOUNDS.STRING_ID_MAX).optional()
 });