@rebuy/rebuy 3.58.0 → 3.60.0

package/dist/server/index.cjs

@@ -383,6 +383,10 @@ var OfferProductVariant = import_zod3.z.object({
   price: import_zod3.z.string(),
   title: import_zod3.z.string()
 });
+var OfferProductReviews = import_zod3.z.object({
+  rating: import_zod3.z.number().positive().max(5),
+  reviewCount: import_zod3.z.number().int().nonnegative()
+});
 var OfferProduct = import_zod3.z.object({
   description: import_zod3.z.string().optional(),
   discount: OfferProductDiscount.optional(),
@@ -398,6 +402,7 @@ var OfferProduct = import_zod3.z.object({
   link: import_zod3.z.string().optional(),
   metafields: import_zod3.z.array(import_zod3.z.object({ key: import_zod3.z.string(), namespace: import_zod3.z.string(), value: import_zod3.z.string() })).optional(),
   options: import_zod3.z.array(OfferProductOption),
+  reviews: OfferProductReviews.nullish().catch(void 0),
   sellingPlanGroups: import_zod3.z.array(import_zod3.z.object({ requiresSellingPlan: import_zod3.z.boolean().optional() })).optional(),
   title: import_zod3.z.string(),
   /** At least one variant — a zero-variant product renders an offer card with no addable merchandise (no Add CTA). `keepValidProduct` drops it with a `variants` drift signal rather than shipping a dead card. */
@@ -406,6 +411,27 @@ var OfferProduct = import_zod3.z.object({
 
 // src/server/b2bAvailability.ts
 var import_zod4 = require("zod");
+
+// src/server/shared.ts
+var REBUY_ENGINE_HOST = "rebuyengine.com";
+var unwrapData = (body) => body && typeof body === "object" && "data" in body ? body.data : body;
+var isEmptyObject = (x) => x == null || typeof x === "object" && !Array.isArray(x) && Object.keys(x).length === 0;
+var UpstreamError = class extends Error {
+  constructor(status, body, message) {
+    super(message ?? `Upstream returned ${status}`);
+    this.body = body;
+    this.name = "UpstreamError";
+    this.status = status;
+  }
+};
+var NotFoundError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "NotFoundError";
+  }
+};
+
+// src/server/b2bAvailability.ts
 var B2B_AVAILABILITY_PATH = "/admin/api/v1/shop/b2b-catalog-availability";
 var productGid = (product) => `gid://shopify/Product/${String(product.id)}`;
 var Verdict = import_zod4.z.record(import_zod4.z.string(), import_zod4.z.boolean());
@@ -413,9 +439,18 @@ var B2bAvailabilityResponse = import_zod4.z.object({
   availability: Verdict.optional(),
   data: import_zod4.z.object({ availability: Verdict.optional() }).optional()
 }).transform(({ availability, data }) => availability ?? data?.availability ?? null);
+var MAX_REASON_LENGTH = 120;
+var failureReason = (error) => {
+  if (!(error instanceof Error)) return "unknown error";
+  const cut = error.message.indexOf(": ");
+  const label2 = (cut === -1 ? error.message : error.message.slice(0, cut)).slice(0, MAX_REASON_LENGTH);
+  if (!(error instanceof UpstreamError)) return label2 || error.name;
+  return label2 && label2 !== `Upstream returned ${error.status}` ? `upstream ${error.status}: ${label2}` : `upstream ${error.status}`;
+};
 var filterByB2bAvailability = async (products, input, ctx) => {
   if (!input.companyLocationId || products.length === 0) return products;
   let verdict;
+  let reason = "unreadable verdict";
   try {
     const response = await ctx.fetchUpstream(
       B2B_AVAILABILITY_PATH,
@@ -426,18 +461,21 @@ var filterByB2bAvailability = async (products, input, ctx) => {
           productIds: products.map(productGid),
           shopifyShopDomain: input.shop
         },
+        /** admin-api verifies it (REB-25081); absent, the call is unauthenticated (log-only there until enforced). */
+        ...ctx.sessionToken && { headers: { Authorization: `Bearer ${ctx.sessionToken}` } },
         host: ctx.host,
         method: "POST"
       }
     );
     const parsed = B2bAvailabilityResponse.safeParse(response);
     verdict = parsed.success ? parsed.data : null;
-  } catch {
+  } catch (error) {
     verdict = null;
+    reason = failureReason(error);
   }
   if (verdict === null) {
     ctx.reportDrift?.({
-      detail: "b2b availability check failed \u2014 products served unfiltered",
+      detail: `b2b availability check failed (${reason}) \u2014 products served unfiltered`,
       kind: "b2bAvailability"
     });
     return products;
@@ -445,265 +483,48 @@ var filterByB2bAvailability = async (products, input, ctx) => {
   return products.filter((product) => verdict[productGid(product)] !== false);
 };
 
-// src/server/shared.ts
-var REBUY_ENGINE_HOST = "rebuyengine.com";
-var unwrapData = (body) => body && typeof body === "object" && "data" in body ? body.data : body;
-var isEmptyObject = (x) => x == null || typeof x === "object" && !Array.isArray(x) && Object.keys(x).length === 0;
-var UpstreamError = class extends Error {
-  constructor(status, body, message) {
-    super(message ?? `Upstream returned ${status}`);
-    this.body = body;
-    this.name = "UpstreamError";
-    this.status = status;
-  }
-};
-var NotFoundError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "NotFoundError";
-  }
-};
-
-// src/server/shopSubtotal.ts
-var shopCurrencyRate = (cart) => {
-  const rate = cart.currencyRate ?? 1;
-  return Number.isFinite(rate) && rate > 0 ? rate : 1;
-};
-var shopSubtotalCents = (cart) => Math.round((cart.subtotal - (cart.discountTotal ?? 0)) / shopCurrencyRate(cart));
-var toShopCents = (majorPresentment, rate) => Math.round(majorPresentment * 100 / rate);
+// src/server/postPurchaseReviewData.ts
+var import_zod17 = require("zod");
 
-// src/schema/cabShopConfig.ts
-var import_zod6 = require("zod");
+// src/schema/postPurchaseProductReviews.ts
+var import_zod12 = require("zod");
 
-// src/schema/driftedMarkets.ts
-var DRIFTED_MARKETS = Object.freeze({ enabled: false });
+// src/schema/widgets/post-purchase-offer/postPurchaseSettings.ts
+var import_zod11 = require("zod");
 
-// src/schema/smartCart.ts
+// src/schema/widgets/post-purchase-offer/common.ts
+var import_compat = require("es-toolkit/compat");
 var import_zod5 = require("zod");
-var SmartCartTierProduct = import_zod5.z.looseObject({
-  handle: import_zod5.z.string().optional(),
-  id: import_zod5.z.coerce.number().optional(),
-  productId: import_zod5.z.coerce.number().optional(),
-  title: import_zod5.z.string().optional(),
-  variantIds: import_zod5.z.array(import_zod5.z.coerce.number()).optional()
-});
-var SmartCartTierExclusion = import_zod5.z.looseObject({
-  collectionIds: import_zod5.z.array(import_zod5.z.coerce.number()).optional().catch(void 0),
-  productIds: import_zod5.z.array(import_zod5.z.coerce.number()).optional().catch(void 0),
-  tags: import_zod5.z.array(import_zod5.z.string()).optional().catch(void 0),
-  type: import_zod5.z.string().optional().catch(void 0)
-});
-var SmartCartTier = import_zod5.z.looseObject({
-  allProducts: import_zod5.z.array(SmartCartTierProduct).optional(),
-  /** Merchant-set tier label (e.g. "Free gift", "$100 reward"), shown on the step row when enabled. */
-  customTierLabel: import_zod5.z.boolean().optional(),
-  customTierLabelText: import_zod5.z.string().optional(),
-  decorativeAmountReachedLabel: import_zod5.z.boolean().optional(),
-  decorativeAmountReachedLabelText: import_zod5.z.string().optional(),
-  decorativeAmountRemainingLabel: import_zod5.z.boolean().optional(),
-  decorativeAmountRemainingLabelText: import_zod5.z.string().optional(),
-  /** Order-discount reward: `'fixedAmount'` (shop-currency dollars) or `'percentage'` (whole percent). */
-  discountAmountFromTotal: import_zod5.z.coerce.number().optional(),
-  discountAmountReachedLabel: import_zod5.z.boolean().optional(),
-  discountAmountReachedLabelText: import_zod5.z.string().optional(),
-  discountAmountRemainingLabel: import_zod5.z.boolean().optional(),
-  discountAmountRemainingLabelText: import_zod5.z.string().optional(),
-  discountType: import_zod5.z.string().optional(),
-  /**
-   * onsite `exclusions` + `exclusions_enabled` (REB-22305): per-tier rules the converter carries onto
-   * `CABProgressTier.exclusions`. `.catch(undefined)` for the same blast-radius reason as `productTierImage`:
-   * one drifted value must degrade to "no tier exclusions", never drop every progress bar for the shop.
-   *
-   * `exclusionsEnabled` is a STRICT boolean on purpose, even though failing open here changes the tier's math
-   * (a non-boolean reads as disabled) rather than just an icon. onsite reads its sibling tier flags strictly —
-   * `shouldFilterOutOfStockVariantsFromTier` is `tier?.filter_oos_variants === true`, and its `progressBar.ts`
-   * types every tier flag as `boolean` — so a stored `1` / `"1"` / `"true"` is "disabled" on the onsite bar too.
-   * A truthiness preprocess would make CAB exclude where onsite does not: the opposite parity break.
-   */
-  exclusions: import_zod5.z.array(SmartCartTierExclusion).optional().catch(void 0),
-  exclusionsEnabled: import_zod5.z.boolean().optional().catch(void 0),
-  filterOosVariants: import_zod5.z.boolean().optional(),
-  id: import_zod5.z.string().optional(),
-  /**
-   * A `null`/absent minimum stays `undefined` (NOT coerced to `0`): a threshold-0 tier is always reached
-   * and would auto-add its gift to every cart. onsite's `isTierDataValid` drops a non-numeric minimum for
-   * exactly this reason; the converter's `renderableTiers` mirrors that (`Number.isFinite`). A literal `0`
-   * is kept — onsite keeps it too. DELIBERATE DIVERGENCE from onsite for string minimums: onsite's
-   * `isTierDataValid` is a strict `typeof === 'number'`, so it drops `'50'`; the converter instead coerces
-   * `'50' → 50` and keeps the tier (a numeric-string minimum is a valid threshold, not a data defect).
-   */
-  minimum: import_zod5.z.preprocess((value) => value == null ? void 0 : value, import_zod5.z.coerce.number().optional()),
-  presentmentCurrencies: import_zod5.z.looseObject({ enabled: import_zod5.z.boolean().optional() }).optional(),
-  productAmountReachedLabel: import_zod5.z.boolean().optional(),
-  productAmountReachedLabelText: import_zod5.z.string().optional(),
-  productAmountRemainingLabel: import_zod5.z.boolean().optional(),
-  productAmountRemainingLabelText: import_zod5.z.string().optional(),
-  products: import_zod5.z.array(SmartCartTierProduct).optional(),
-  /**
-   * onsite `product_tier_element_size`: the step-row icon's square size as a px STRING (`'18px'` …
-   * `'36px'` — the admin's five-value Size control, default `'18px'`). React stamps it onto the icon
-   * SVG's `width`/`height` (`getProgressStepIconSize`), so the milestone renders at the merchant's
-   * chosen size; the converter turns it into `CABProgressTier.iconSizePx` for the CAB renderer.
-   *
-   * `.catch(undefined)` for the same blast-radius reason as `productTierImage` below: this key was
-   * previously unknown-and-ignored by the `looseObject`, and `SmartCartConfig` is parsed
-   * `.nullish().catch(undefined)` with no intermediate catch, so one drifted value (a bare number, a
-   * `'2rem'`) would drop EVERY progress bar for the shop rather than just this setting. Failing open to
-   * `undefined` lands on the documented 18px default — strictly safer than that blast radius. The
-   * converter parses the number out and clamps it, so a junk-but-string value degrades the same way.
-   */
-  productTierElementSize: import_zod5.z.string().optional().catch(void 0),
-  /**
-   * onsite `product_tier_image`: on a product (gift) tier, show the gift's product image in the step-row
-   * slot instead of the generic bag icon (React `TierProgressIcon` swaps in the image when this is set and
-   * an image resolves). Per-tier; the client resolves the image (config carries only product IDs).
-   *
-   * `.catch(undefined)` is load-bearing. This key was previously unknown-and-ignored by the `looseObject`;
-   * declaring it as a real boolean means a stored non-boolean (`1` / `"1"` / `"true"`) would now FAIL the
-   * tier — and since `SmartCartConfig` is parsed `.nullish().catch(undefined)` (userConfig/cabShopConfig)
-   * with no intermediate catch, one drifted flag would drop EVERY progress bar for the shop, not just the
-   * flag. The converter only reads it for truthiness (`gift && tier.productTierImage`), so failing open to
-   * `undefined` (bag-icon fallback, the documented default) is strictly safer than that blast radius.
-   */
-  productTierImage: import_zod5.z.boolean().optional().catch(void 0),
-  type: import_zod5.z.string().optional(),
-  /**
-   * onsite's PER-TIER unit switch (`unlock_condition_type`): `'item_quantity'` makes `minimum` an
-   * item count (checked before any money handling — no ×100, no FX, no presentment overrides,
-   * mirroring onsite `getTierMinimum`); anything else (or absent) keeps the money semantics.
-   */
-  unlockConditionType: import_zod5.z.string().optional()
-});
-var SmartCartBar = import_zod5.z.looseObject({
-  countryCodes: import_zod5.z.array(import_zod5.z.string()).optional(),
-  /**
-   * onsite `exclude_discount_in_subtotal`: measure progress against the PRE-discount subtotal so an
-   * applied code/order discount doesn't lower progress. The client adds cart discount allocations back.
-   */
-  excludeDiscountInSubtotal: import_zod5.z.boolean().optional(),
-  /** Products excluded from the progress subtotal; the client subtracts their variants' cart cost. */
-  excludedProducts: import_zod5.z.array(import_zod5.z.looseObject({ variantIds: import_zod5.z.array(import_zod5.z.coerce.number()).optional() })).optional(),
-  freeShippingOnSubscription: import_zod5.z.boolean().optional(),
-  geolocationEnabled: import_zod5.z.boolean().optional(),
-  id: import_zod5.z.string().optional(),
-  language: import_zod5.z.looseObject({
-    freeShippingReached: import_zod5.z.string().optional(),
-    freeShippingRemaining: import_zod5.z.string().optional(),
-    giftAreaTitle: import_zod5.z.string().optional()
-  }).optional(),
-  name: import_zod5.z.string().optional(),
-  tiers: import_zod5.z.array(SmartCartTier).optional()
-});
-var SmartCartComponent = import_zod5.z.looseObject({
-  settings: import_zod5.z.looseObject({ bars: import_zod5.z.array(SmartCartBar).optional() }).optional(),
-  type: import_zod5.z.string().optional()
-});
-var SmartCartConfig = import_zod5.z.looseObject({
-  components: import_zod5.z.array(SmartCartComponent).optional()
-});
+var strictNumber = import_zod5.z.union([
+  import_zod5.z.number(),
+  import_zod5.z.string().transform((value) => (0, import_compat.toNumber)((0, import_compat.replace)((0, import_compat.toString)(value), /[^0-9.]/g, "")) || 0),
+  import_zod5.z.unknown().transform(() => 0)
+]);
 
-// src/schema/cabShopConfig.ts
-var CabActiveExperiment = import_zod6.z.object({
-  data: import_zod6.z.array(
-    import_zod6.z.object({
-      elementId: import_zod6.z.coerce.number(),
-      id: import_zod6.z.coerce.number(),
-      traffic: import_zod6.z.coerce.number()
-    })
-  ),
-  id: import_zod6.z.coerce.number(),
-  placeholderId: import_zod6.z.coerce.number().nullable(),
-  type: import_zod6.z.string()
-});
-var CabShopConfig = import_zod6.z.object({
-  /**
-   * Per-element resilient: parse as `unknown[]` (non-array → `[]`), then keep only the experiments that
-   * validate. A single drifted experiment drops itself instead of `.catch`-ing the WHOLE array to `[]` and
-   * silently disabling every live A/B test fleet-wide.
-   */
-  activeExperiments: import_zod6.z.array(import_zod6.z.unknown()).catch([]).default([]).transform(
-    (experiments) => experiments.flatMap((experiment) => {
-      const result = CabActiveExperiment.safeParse(experiment);
-      return result.success ? [result.data] : [];
-    })
-  ),
-  /**
-   * Only the two fields the smart-cart entitlement gate reads (`shortName`/`isActive`). Per-element
-   * resilient like `activeExperiments`: a drifted package entry degrades to an inert `''`/false one that
-   * matches nothing, so a real active `cart-merchandising` package still gates correctly and a sibling
-   * drift never fails the shared config parse. Note the salvage is fail-CLOSED, not fail-open, for an
-   * entitled v6 shop: a malformed whole array (⇒ `[]`) or an inerted `cart-merchandising` entry (e.g.
-   * `is_active: 1` ⇒ inactive) makes the gate find no active package and drop every bar. That matches
-   * React's "no proof of entitlement ⇒ render null", but it silently removes bars — so the server gate
-   * ({@link file://../server/widgetSettings.ts} `fetchProgressBarContext`) emits a `shopConfig` drift
-   * when it sees the inert-entry sentinel (`shortName === ''`). The whole-array `[]` case leaves no
-   * sentinel and is not separately signalable here.
-   */
-  activePackages: import_zod6.z.array(import_zod6.z.object({ isActive: import_zod6.z.boolean(), shortName: import_zod6.z.string() }).catch({ isActive: false, shortName: "" })).catch([]).default([]),
-  apiKey: import_zod6.z.string(),
-  /** The shop's billing generation; the smart-cart entitlement gate only fires for `'v6'`. Missing/drift ⇒ `null` (fail open, ungated). */
-  billingVersion: import_zod6.z.string().nullable().catch(null).default(null),
-  /**
-   * The shop's rotating cache-buster: `onsite_cache_key` internally — a unix timestamp the engine bumps,
-   * and the edge copy of this config purges, on every widget/settings/theme edit — but serialized on the
-   * wire as `cache_key`, which `deepCamelCase` maps to this field (renaming it `onsiteCacheKey` would
-   * sever the mapping silently; the wire-level assertion in `userConfig.test.ts` is what fails loudly).
-   * Threaded onto the widgets/settings read as `cache_key` so the engine marks the response
-   * immutable-cacheable and the `cached.*` edge serves it fresh-by-URL. The engine sends a numeric
-   * string — coerce — but admit only number/string inputs and constrain to a positive integer: a bare
-   * coercion folds `null`/`''`/`false` to `0` and `true` to `1` — "valid" numbers that would go upstream
-   * as a constant never-rotating buster and pin the edge copy permanently stale. A real key is always a
-   * positive int sent as number or string, so everything else lands on `.catch()` and degrades that read
-   * to un-busted (origin-served — slower, never stale), never a parse fail.
-   */
-  cacheKey: import_zod6.z.union([import_zod6.z.number(), import_zod6.z.string()]).transform((value) => Number(value)).pipe(import_zod6.z.number().int().positive()).optional().catch(void 0),
-  /**
-   * The shop's base-currency ISO code (e.g. `'USD'`). CAB derives the shop minor-unit exponent from it
-   * (`currencyDecimals`) so a Functions-applied fixed discount — whose amount is in shop minor units —
-   * converts to the buyer's currency exactly in a cross-decimal market. `.catch()` like its siblings: a
-   * missing/renamed currency degrades to "unknown" (client falls back to buyer decimals), never a parse fail.
-   */
-  currency: import_zod6.z.string().optional().catch(void 0),
-  /**
-   * The merchant's "Use Markets in Data Sources" toggle. The engine (CI2) never reads it on the serve
-   * path, so the proxy honouring it before sending market context is what makes the setting mean
-   * anything (REB-21688). Fail-CLOSED, unlike the fail-open siblings: a missing/null/drifted field reads
-   * as markets OFF — market context silently dropped (engine serves shop-default market), never sent
-   * against the merchant's setting. The OFF-reading salvages stay distinguishable: missing AND null are
-   * the engine's normal absent vocabulary (`.nullish()`, like `monetize`/`billingVersion`) and read as
-   * the plain default — not drift — while only a drifted SHAPE `.catch`es, to the {@link DRIFTED_MARKETS}
-   * identity sentinel, so `fetchUserConfig` can emit a `shopConfig` drift for the one case that means an
-   * engine rename/retype; otherwise a markets-enabled merchant degrading to shop-default pricing would
-   * be indistinguishable from markets genuinely off. The missing-key case is EXPLICIT via `.default()`
-   * (a factory, so parses never share a mutable object) rather than inferred from zod running an
-   * optional key's transform on `undefined`; `null` flows past the default through `.nullish()` into the
-   * transform. `Readonly` on the output type because the drifted salvage IS frozen — an assignment to
-   * `markets.enabled` downstream would throw only for drifted shops in production, so surface direct
-   * writes to tsc (a guard for the direct case only: TS doesn't check `readonly` in assignability, so
-   * laundering through a mutable-shaped alias still compiles).
-   * The inner `enabled` stays strict on purpose: `{ enabled: null }` is a genuine retype and drifting is
-   * the correct answer (the editor-path `ShopConfig.markets` would hard-fail the same payload).
-   */
-  markets: import_zod6.z.object({ enabled: import_zod6.z.boolean() }).nullish().catch(DRIFTED_MARKETS).default(() => ({ enabled: false })).transform((markets) => markets ?? { enabled: false }),
-  monetize: import_zod6.z.object({ publisherKey: import_zod6.z.string().nullable() }).nullish().catch(void 0),
-  shopId: import_zod6.z.number().optional().catch(void 0),
-  /**
-   * The merchant's display name ("Gift Basket Store") — the Monetize header copy reads it.
-   * `.catch()` like its siblings: a missing/drifted name degrades the header to the
-   * myshopify-domain slug (the pre-CAB React fallback), never a parse fail. An empty string is a
-   * VALID parse — the slug fallback for `''` (and whitespace/tag-only names) lives in
-   * composeOffer's `||` chain, not here.
-   */
-  shopName: import_zod6.z.string().nullish().catch(void 0)
-});
-var CabUserConfig = import_zod6.z.object({
-  shop: CabShopConfig,
-  smartCart: SmartCartConfig.nullish().catch(void 0)
-});
+// src/schema/widgets/post-purchase-offer/constants.ts
+var import_zod6 = require("zod");
+var blockTypes = [
+  "callout_banner",
+  "image",
+  "image_content",
+  "pay_button",
+  "product_information",
+  "separator",
+  "text",
+  "timer"
+];
+var blockType = import_zod6.z.enum(blockTypes);
+var BlockType = blockType.enum;
 
-// src/schema/widgets/checkout-and-beyond/image.ts
-var import_uuid13 = require("uuid");
-var import_zod28 = require("zod");
+// src/schema/widgets/post-purchase-offer/postPurchaseBlocks.ts
+var import_compat4 = require("es-toolkit/compat");
+var import_uuid2 = require("uuid");
+var import_zod10 = require("zod");
+
+// src/schema/widgets/checkout-and-beyond/text.ts
+var import_compat3 = require("es-toolkit/compat");
+var import_uuid = require("uuid");
+var import_zod9 = require("zod");
 
 // src/schema/widgets/checkout-and-beyond/common.ts
 var freezeEnum = (values2) => Object.freeze(Object.fromEntries(values2.map((v) => [v, v])));
@@ -857,6 +678,7 @@ var sectionTypes = [
   "variants"
 ];
 var SectionType = freezeEnum(sectionTypes);
+var SALVAGED_SECTION_TYPE = "unknown";
 var spacings = ["none", "extraTight", "tight", "base", "loose", "extraLoose"];
 var Spacing = freezeEnum(spacings);
 var textAlignments = ["start", "center", "end"];
@@ -907,34 +729,1092 @@ var widgetTypes = [
 ];
 var WidgetType = freezeEnum(widgetTypes);
 
-// src/schema/widgets/checkout-and-beyond/icons.ts
-var iconNames = [
-  "alert-circle",
-  "alert-triangle",
-  "alert-triangle-filled",
-  "arrow-down",
-  "arrow-left",
-  "arrow-right",
-  "arrow-up",
-  "arrow-up-right",
-  "bag",
-  "bullet",
-  "calendar",
-  "camera",
-  "caret-down",
-  "cart",
-  "cash-dollar",
-  "categories",
-  "check",
-  "check-circle",
-  "check-circle-filled",
-  "chevron-down",
-  "chevron-left",
-  "chevron-right",
-  "chevron-up",
-  "circle",
-  "clipboard",
-  "clock",
+// src/schema/widgets/checkout-and-beyond/regex.ts
+var DYNAMIC_TOKEN_REGEX = /^\{\{\s*[A-Za-z]+\s*\}\}$/;
+var HEX_COLOR_REGEX = /^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/;
+var ROOT_RELATIVE_PATH_REGEX = /^\/(?!\/)/;
+var HTML_TAGS_REGEX = /<\/?[a-zA-Z][^>]*>/g;
+
+// src/schema/widgets/checkout-and-beyond/utils.ts
+var import_es_toolkit2 = require("es-toolkit");
+var import_compat2 = require("es-toolkit/compat");
+
+// src/transforms/convertNumericObjects.ts
+var import_es_toolkit = require("es-toolkit");
+var ARRAY_INDEX_STRING = /^(?:0|[1-9]\d*)$/;
+var hasOnlyNumericKeys = (input, requireCompleteRun) => {
+  const keys = Object.keys(input);
+  if (keys.length === 0) return false;
+  if (!keys.every((key) => ARRAY_INDEX_STRING.test(key) && Number.isSafeInteger(Number(key)))) return false;
+  if (!requireCompleteRun) return true;
+  const sorted = keys.map(Number).sort((a, b) => a - b);
+  return sorted.every((n, i) => n === i);
+};
+var numericObjectToArray = (input) => Object.entries(input).sort(([a], [b]) => Number(a) - Number(b)).map(([, value]) => value);
+var convert = (input, requireCompleteRun) => {
+  if (Array.isArray(input)) return input.map((item) => convert(item, requireCompleteRun));
+  if ((0, import_es_toolkit.isPlainObject)(input)) {
+    if (hasOnlyNumericKeys(input, requireCompleteRun)) {
+      return numericObjectToArray(input).map((item) => convert(item, requireCompleteRun));
+    }
+    const out = {};
+    for (const [key, value] of Object.entries(input)) out[key] = convert(value, requireCompleteRun);
+    return out;
+  }
+  return input;
+};
+var convertNumericObjects = (input) => convert(input, true);
+
+// src/schema/widgets/checkout-and-beyond/utils.ts
+var isHTML = (html = "") => {
+  if (typeof window !== "undefined") {
+    const parser = new DOMParser();
+    const doc = parser.parseFromString(html, "text/html");
+    const hasHTML = (nodeList) => Array.from(nodeList).some((node) => node.nodeType === 1);
+    return hasHTML(doc.body.childNodes) || hasHTML(doc.head.childNodes);
+  }
+  return html.search(HTML_TAGS_REGEX) !== -1;
+};
+var hasHTMLInDoc = (doc) => doc.content.some(({ content = [] }) => content.some(({ text: text2 }) => isHTML(text2)));
+var checkForHTML = (input) => !((0, import_compat2.isString)(input) && isHTML(input) || (0, import_es_toolkit2.isPlainObject)(input) && hasHTMLInDoc(input));
+var NO_HTML = { message: "HTML is not supported" };
+var isSectionType = (sectionType) => (section) => (0, import_compat2.get)(section, "sectionType") === sectionType;
+var isBannerType = isSectionType(SectionType.banner);
+var isButtonType = isSectionType(SectionType.button);
+var isCarouselType = isSectionType(SectionType.carousel);
+var isCartLineType = isSectionType(SectionType.cartLine);
+var isDataSourceType = isSectionType(
+  SectionType.dataSource
+);
+var isDiscountType = isSectionType(SectionType.discount);
+var isImageType = isSectionType(SectionType.image);
+var isLayoutType = isSectionType(SectionType.layout);
+var isMonetizeType = isSectionType(SectionType.monetize);
+var isOffersType = isSectionType(SectionType.offers);
+var isProductType = isSectionType(SectionType.product);
+var isProductsType = isSectionType(SectionType.products);
+var isProgressBarType = isSectionType(
+  SectionType.progressBar
+);
+var isQuantityType = isSectionType(SectionType.quantity);
+var isReviewsType = isSectionType(SectionType.reviews);
+var isTextType = isSectionType(SectionType.text);
+var isVariantsType = isSectionType(SectionType.variants);
+
+// src/schema/widgets/checkout-and-beyond/variables.ts
+var import_zod8 = require("zod");
+
+// src/schema/widgets/checkout-and-beyond/rule.ts
+var import_zod7 = require("zod");
+var ruleTypes = [
+  "cart",
+  "cart_count",
+  "cart_item_count",
+  "cart_line_count",
+  "cart_subtotal",
+  "collection",
+  "customer",
+  "customer_order_count",
+  "customer_tag",
+  "customer_total_spent",
+  "date",
+  "product",
+  "product_tag",
+  "product_title",
+  "product_type",
+  "product_vendor"
+];
+var ruleType = import_zod7.z.enum(ruleTypes);
+var RuleType = ruleType.enum;
+var ruleOperators = [
+  "after",
+  "anything",
+  "before",
+  "contains",
+  "contains_any",
+  "does_not_contain",
+  "does_not_contain_any",
+  "equals",
+  "does_not_equal",
+  "greater_than",
+  "less_than"
+];
+var ruleOperator = import_zod7.z.enum(ruleOperators);
+var RuleOperator = ruleOperator.enum;
+var RuleCondition = import_zod7.z.object({
+  operator: import_zod7.z.enum(ruleOperators).default(RuleOperator.anything),
+  products: import_zod7.z.union([import_zod7.z.array(import_zod7.z.unknown()), import_zod7.z.strictObject({}).transform(() => [])]).default(() => []),
+  type: import_zod7.z.enum(ruleTypes).default(RuleType.cart_subtotal),
+  value: import_zod7.z.coerce.string().default("")
+});
+var RuleLogicBlock = import_zod7.z.object({
+  rules: import_zod7.z.array(RuleCondition).default(() => [])
+});
+var CABRulesetEntry = import_zod7.z.object({
+  exitIfMatched: import_zod7.z.boolean().default(true),
+  logic: import_zod7.z.array(RuleLogicBlock).default(() => []),
+  output: import_zod7.z.array(
+    import_zod7.z.object({
+      key: import_zod7.z.string().default("should_show"),
+      type: import_zod7.z.literal("data_json").default("data_json"),
+      value: import_zod7.z.string().default("true")
+    })
+  ).default(() => [{ key: "should_show", type: "data_json", value: "true" }])
+});
+var CABRuleset = import_zod7.z.union([import_zod7.z.array(CABRulesetEntry), import_zod7.z.strictObject({}).transform(() => [])]).default(() => []);
+
+// src/schema/widgets/checkout-and-beyond/variables.ts
+var variableEffect = import_zod8.z.enum(variableEffects);
+var CABVariableSeed = import_zod8.z.object({
+  dataSourceId: import_zod8.z.number().nullable().default(null),
+  ruleset: CABRuleset
+});
+var CABBooleanVariable = import_zod8.z.object({
+  /**
+   * Holds until the first seed verdict lands (and forever, for unseeded variables). Omitted, it derives
+   * from seededness — `false` with a `seed` (visibility is EARNED), `true` without — via the transform
+   * below; a cross-field default has no `.default()` spelling. An explicit value always wins.
+   */
+  defaultValue: import_zod8.z.boolean().optional(),
+  name: import_zod8.z.string().min(1),
+  seed: CABVariableSeed.optional(),
+  /** Defaulted so every stored declaration (all boolean before `text` existed) parses unchanged. */
+  type: import_zod8.z.literal(VariableType.boolean).default(VariableType.boolean)
+});
+var CABTextVariable = import_zod8.z.object({
+  defaultValue: import_zod8.z.string(),
+  name: import_zod8.z.string().min(1),
+  seed: import_zod8.z.never().optional(),
+  type: import_zod8.z.literal(VariableType.text)
+});
+var CABNumberVariable = import_zod8.z.object({
+  defaultValue: import_zod8.z.number(),
+  name: import_zod8.z.string().min(1),
+  seed: import_zod8.z.never().optional(),
+  type: import_zod8.z.literal(VariableType.number)
+});
+var CABVariable = import_zod8.z.union([CABTextVariable, CABNumberVariable, CABBooleanVariable]).transform(
+  (variable) => variable.type === VariableType.boolean ? { ...variable, defaultValue: variable.defaultValue ?? variable.seed === void 0 } : variable
+);
+var CABVariableEffect = import_zod8.z.object({
+  effect: variableEffect.default(VariableEffect.toggle),
+  variable: import_zod8.z.string().min(1)
+});
+var CABVisibility = import_zod8.z.object({
+  variable: import_zod8.z.string().min(1),
+  visibleWhen: import_zod8.z.boolean().default(true)
+});
+var contentOperator = import_zod8.z.enum(contentOperators);
+var resultCountOperator = import_zod8.z.enum(resultCountOperators);
+var resultTagOperator = import_zod8.z.enum(resultTagOperators);
+var mutatorEvent = import_zod8.z.enum(mutatorEvents);
+var CABContentTrigger = import_zod8.z.object({
+  operator: contentOperator.default(ContentOperator.is_empty),
+  type: import_zod8.z.literal("content")
+});
+var CABResultCountTrigger = import_zod8.z.object({
+  operator: resultCountOperator.default(ResultCountOperator.equals),
+  type: import_zod8.z.literal("result_count"),
+  value: import_zod8.z.number().default(0)
+});
+var CABResultTagTrigger = import_zod8.z.object({
+  operator: resultTagOperator.default(ResultTagOperator.contains),
+  type: import_zod8.z.literal("result_tag"),
+  value: import_zod8.z.string().min(1)
+});
+var CABEventTrigger = import_zod8.z.object({
+  event: mutatorEvent,
+  type: import_zod8.z.literal("event")
+});
+var CABVariableTrigger = import_zod8.z.discriminatedUnion("type", [
+  CABContentTrigger,
+  CABEventTrigger,
+  CABResultCountTrigger,
+  CABResultTagTrigger
+]);
+var CABVariableMutator = import_zod8.z.object({
+  effect: variableEffect.default(VariableEffect.set_false),
+  variable: import_zod8.z.string().min(1),
+  when: CABVariableTrigger
+});
+var CABVariableFields = {
+  mutators: import_zod8.z.array(CABVariableMutator).optional(),
+  variables: import_zod8.z.array(CABVariable).refine((variables) => new Set(variables.map(({ name }) => name)).size === variables.length, {
+    message: "variable names must be unique within a section"
+  }).optional(),
+  visibility: CABVisibility.optional()
+};
+
+// src/schema/widgets/checkout-and-beyond/text.ts
+var enumOrOmit = (...vals) => import_zod9.z.string().transform((val) => vals.includes(val) ? val : void 0).optional();
+var TiptapText = import_zod9.z.object({
+  marks: import_zod9.z.union([
+    import_zod9.z.array(
+      import_zod9.z.discriminatedUnion("type", [
+        import_zod9.z.object({ type: import_zod9.z.literal("bold") }),
+        import_zod9.z.object({ type: import_zod9.z.literal("italic") }),
+        import_zod9.z.object({
+          attrs: import_zod9.z.object({
+            class: import_zod9.z.string().nullable(),
+            href: import_zod9.z.union([
+              import_zod9.z.url(),
+              import_zod9.z.literal("#"),
+              import_zod9.z.string().regex(DYNAMIC_TOKEN_REGEX),
+              import_zod9.z.string().regex(ROOT_RELATIVE_PATH_REGEX)
+            ]),
+            rel: import_zod9.z.string().default("noopener noreferrer nofollow"),
+            target: import_zod9.z.string().default("_blank")
+          }),
+          type: import_zod9.z.literal("link")
+        }),
+        import_zod9.z.object({ type: import_zod9.z.literal("strike") }),
+        import_zod9.z.object({
+          attrs: import_zod9.z.object({
+            color: enumOrOmit(...textColorNames).default(TextColorName.base),
+            fontSize: enumOrOmit(...textSizeNames).default(TextSizeName.base)
+          }),
+          type: import_zod9.z.literal("textStyle")
+        })
+      ])
+    ),
+    import_zod9.z.strictObject({}).transform(() => [])
+  ]).optional(),
+  text: import_zod9.z.string().default(""),
+  type: import_zod9.z.literal("text").default("text")
+});
+var TiptapParagraph = import_zod9.z.object({
+  attrs: import_zod9.z.object({
+    textAlign: enumOrOmit(...textAlignments)
+  }).default({ textAlign: TextAlignment.start }),
+  content: import_zod9.z.union([import_zod9.z.array(TiptapText), import_zod9.z.strictObject({}).transform(() => [])]).default(() => []),
+  type: import_zod9.z.literal("paragraph").default("paragraph")
+});
+var TiptapDocument = import_zod9.z.object({
+  attrs: import_zod9.z.object({
+    blockSpacing: enumOrOmit(...spacings)
+  }).default({ blockSpacing: Spacing.base }),
+  content: import_zod9.z.union([import_zod9.z.array(TiptapParagraph), import_zod9.z.strictObject({}).transform(() => [])]).default(() => [TiptapParagraph.parse({})]),
+  type: import_zod9.z.literal("doc").default("doc")
+});
+var CABTextTier = import_zod9.z.object({
+  threshold: import_zod9.z.number().int().nonnegative(),
+  thresholds: import_zod9.z.record(import_zod9.z.string(), import_zod9.z.number().int().nonnegative()).default(() => ({})),
+  tierId: import_zod9.z.string().optional(),
+  tierType: import_zod9.z.enum(progressTierTypes).default(ProgressTierType.shipping)
+});
+var CABTextSection = import_zod9.z.object({
+  ...CABVariableFields,
+  buttonField: import_zod9.z.enum(buttonFields).optional(),
+  content: import_zod9.z.record(import_zod9.z.string(), import_zod9.z.union([import_zod9.z.string(), TiptapDocument]).refine(checkForHTML, NO_HTML).optional()).default({ en: TiptapDocument.parse({}) }).optional(),
+  name: import_zod9.z.string().optional(),
+  optionId: import_zod9.z.number().optional(),
+  sectionId: import_zod9.z.uuid().default(() => (0, import_uuid.v7)()),
+  sectionType: import_zod9.z.literal(SectionType.text).default(SectionType.text),
+  tier: CABTextTier.optional()
+}).superRefine(({ buttonField, content }, ctx) => {
+  if (buttonField === ButtonField.destinationUrl && content) {
+    (0, import_compat3.forEach)(content, (value, lang) => {
+      if (value && (0, import_compat3.isString)(value)) {
+        if (DYNAMIC_TOKEN_REGEX.test(value)) return;
+        try {
+          new URL(value);
+        } catch {
+          ctx.addIssue({
+            code: "custom",
+            message: "Invalid URL",
+            path: ["content", lang]
+          });
+        }
+      }
+    });
+  }
+});
+
+// src/schema/widgets/post-purchase-offer/postPurchaseBlocks.ts
+var TextAlignment2 = import_zod10.z.union([import_zod10.z.enum(["leading", "center", "trailing"]), import_zod10.z.unknown().transform(() => "leading")]);
+var TextSize = import_zod10.z.union([
+  import_zod10.z.enum(["xsmall", "small", "base", "default", "medium", "large", "xlarge"]),
+  import_zod10.z.unknown().transform(() => "medium")
+]);
+var CalloutBannerBlock = import_zod10.z.object({
+  id: import_zod10.z.string().optional().default(() => (0, import_uuid2.v4)()),
+  name: import_zod10.z.string().optional(),
+  settings: import_zod10.z.object({
+    superTitle: import_zod10.z.union([import_zod10.z.string(), TiptapDocument]).default(() => "Limited-time Offer"),
+    title: import_zod10.z.union([import_zod10.z.string(), TiptapDocument]).default(() => "Add this customer favorite to your order")
+  }),
+  styles: import_zod10.z.object({
+    superTitleEmphasized: import_zod10.z.boolean().default(false),
+    superTitleSize: TextSize.default("large"),
+    textAlignment: TextAlignment2.default("center"),
+    titleEmphasized: import_zod10.z.boolean().default(true),
+    titleSize: TextSize.default("large")
+  }),
+  type: import_zod10.z.literal(BlockType.callout_banner).default(BlockType.callout_banner)
+});
+var ImageBlock = import_zod10.z.object({
+  id: import_zod10.z.string().optional().default(() => (0, import_uuid2.v4)()),
+  name: import_zod10.z.string().optional(),
+  settings: import_zod10.z.union([
+    import_zod10.z.object({
+      /** This isn't used in the post-purchase offer widget */
+      alt: import_zod10.z.string().optional().default(""),
+      image: import_zod10.z.union([import_zod10.z.literal(""), import_zod10.z.url()]).default(""),
+      imageSize: import_zod10.z.number().default(20),
+      imageType: import_zod10.z.enum(["URL", "UPLOAD"]).default("URL")
+    }),
+    import_zod10.z.array(import_zod10.z.never()).transform(() => ({}))
+  ]),
+  type: import_zod10.z.literal(BlockType.image).default(BlockType.image)
+});
+var ImageContentBlock = import_zod10.z.object({
+  id: import_zod10.z.string().optional().default(() => (0, import_uuid2.v4)()),
+  name: import_zod10.z.string().optional(),
+  settings: import_zod10.z.object({
+    alt: import_zod10.z.string().optional().default(""),
+    description: import_zod10.z.union([import_zod10.z.string(), TiptapDocument, import_zod10.z.null()]).default(
+      "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum."
+    ),
+    descriptionSize: TextSize.default("medium"),
+    horizontalAlignment: TextAlignment2.default("leading"),
+    image: import_zod10.z.union([import_zod10.z.literal(""), import_zod10.z.url()]).default(""),
+    imagePlacement: import_zod10.z.enum(["bottom", "left", "right", "top"]).optional().default("left"),
+    imageSize: import_zod10.z.number().default(20),
+    superTitle: import_zod10.z.union([import_zod10.z.string(), TiptapDocument]).default("Lorem Ipsum!"),
+    superTitleSize: TextSize.default("medium"),
+    /** This isn't configurable in the admin-nextjs editor */
+    swapContent: import_zod10.z.boolean().optional().default(false),
+    title: import_zod10.z.union([import_zod10.z.string(), TiptapDocument]).nullable().default("Lorem ipsum dolor sit amet"),
+    titleSize: TextSize.default("medium")
+  }),
+  type: import_zod10.z.literal(BlockType.image_content).default(BlockType.image_content)
+});
+var PayButtonBlock = import_zod10.z.object({
+  id: import_zod10.z.string().optional().default(() => (0, import_uuid2.v4)()),
+  name: import_zod10.z.string().optional(),
+  settings: import_zod10.z.union([
+    import_zod10.z.object({
+      label: import_zod10.z.string().default("Pay Now")
+    }),
+    import_zod10.z.array(import_zod10.z.never()).transform(() => ({
+      label: "Pay Now"
+    }))
+  ]),
+  styles: import_zod10.z.union([
+    import_zod10.z.object({
+      buttonWidth: import_zod10.z.number().min(10).max(100).default(50)
+    }),
+    import_zod10.z.array(import_zod10.z.never()).transform(() => ({
+      buttonWidth: 50
+    }))
+  ]),
+  type: import_zod10.z.literal(BlockType.pay_button).default(BlockType.pay_button)
+});
+var ProductInformationBlock = import_zod10.z.object({
+  /** This isn't configurable in the admin-nextjs editor */
+  hideProductImage: import_zod10.z.boolean().optional().default(false),
+  id: import_zod10.z.string().optional().default(() => (0, import_uuid2.v4)()),
+  name: import_zod10.z.string().optional(),
+  type: import_zod10.z.literal(BlockType.product_information).default(BlockType.product_information)
+});
+var SeparatorBlock = import_zod10.z.object({
+  id: import_zod10.z.string().optional().default(() => (0, import_uuid2.v4)()),
+  name: import_zod10.z.string().optional(),
+  type: import_zod10.z.literal(BlockType.separator).default(BlockType.separator)
+});
+var TextBlock = import_zod10.z.object({
+  id: import_zod10.z.string().optional().default(() => (0, import_uuid2.v4)()),
+  name: import_zod10.z.string().optional(),
+  settings: import_zod10.z.object({
+    description: import_zod10.z.union([import_zod10.z.string(), TiptapDocument]).optional().default(
+      "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum."
+    ),
+    /** This isn't used in the post-purchase offer widget */
+    descriptionSize: TextSize.default("medium"),
+    horizontalAlignment: TextAlignment2.default("leading"),
+    superTitle: import_zod10.z.union([import_zod10.z.string(), TiptapDocument]).default("Super Title"),
+    /** This isn't used in the post-purchase offer widget */
+    superTitleSize: TextSize.default("medium"),
+    title: import_zod10.z.union([import_zod10.z.string(), TiptapDocument]).nullable().default("Lorem ipsum dolor sit amet."),
+    /** This isn't used in the post-purchase offer widget */
+    titleSize: TextSize.default("medium")
+  }),
+  type: import_zod10.z.literal(BlockType.text).default(BlockType.text)
+});
+var TimerBlock = import_zod10.z.object({
+  id: import_zod10.z.string().optional().default(() => (0, import_uuid2.v4)()),
+  name: import_zod10.z.string().optional(),
+  settings: import_zod10.z.object({
+    durationMinutes: import_zod10.z.number().min(0).default(10),
+    durationSeconds: import_zod10.z.union([import_zod10.z.number().min(0), import_zod10.z.unknown().transform(() => 0)]).default(0),
+    endOffer: import_zod10.z.boolean().default(true),
+    title: import_zod10.z.union([import_zod10.z.string(), TiptapDocument]).default("Hurry \u2014 your special offer ends in:")
+  }),
+  styles: import_zod10.z.object({
+    textAlignment: TextAlignment2.default("center"),
+    timerBackgroundColor: import_zod10.z.enum(["info", "warning", "success", "critical"]).default("warning"),
+    timerEmphasized: import_zod10.z.union([import_zod10.z.boolean(), import_zod10.z.unknown().transform(() => true)]).default(true),
+    timerSize: TextSize.default("medium"),
+    timerWidth: import_zod10.z.number().min(10).max(100).optional().default(100),
+    titleEmphasized: import_zod10.z.union([import_zod10.z.boolean(), import_zod10.z.unknown().transform(() => true)]).default(false),
+    titleSize: TextSize.default("medium")
+  }),
+  type: import_zod10.z.literal(BlockType.timer).default(BlockType.timer)
+});
+var PostPurchaseBlock = import_zod10.z.discriminatedUnion("type", [
+  CalloutBannerBlock,
+  ImageBlock,
+  ImageContentBlock,
+  PayButtonBlock,
+  ProductInformationBlock,
+  SeparatorBlock,
+  TextBlock,
+  TimerBlock
+]);
+
+// src/schema/widgets/post-purchase-offer/postPurchaseSettings.ts
+var PostPurchaseSettings = import_zod11.z.object({
+  advance: import_zod11.z.object({ removePartialOrder: import_zod11.z.boolean().default(true) }).optional().default(() => ({ removePartialOrder: true })),
+  blocks: import_zod11.z.union([import_zod11.z.array(PostPurchaseBlock), import_zod11.z.unknown().transform(() => [])]).default(() => [
+    PostPurchaseBlock.parse({ settings: {}, styles: {}, type: BlockType.timer }),
+    PostPurchaseBlock.parse({ settings: {}, styles: {}, type: BlockType.callout_banner }),
+    PostPurchaseBlock.parse({ type: BlockType.product_information })
+  ]),
+  columnLayout: import_zod11.z.boolean().optional(),
+  discount: import_zod11.z.object({
+    amount: strictNumber.default(30),
+    shouldShowSavingText: import_zod11.z.boolean().optional().default(true),
+    type: import_zod11.z.enum(["none", "fixed_amount", "percentage"]).default("none")
+  }),
+  discountedFrom: import_zod11.z.enum(["price", "compare_at_price"]).optional().default("price"),
+  endpoint: import_zod11.z.string().optional(),
+  integrations: import_zod11.z.object({
+    judgeme: import_zod11.z.boolean().default(false),
+    junip: import_zod11.z.boolean().optional().default(false),
+    klaviyo: import_zod11.z.boolean().default(false),
+    loox: import_zod11.z.boolean().default(false),
+    okendo: import_zod11.z.boolean().default(false),
+    opinew: import_zod11.z.boolean().optional().default(false),
+    reviewsio: import_zod11.z.boolean().optional().default(false),
+    stamped: import_zod11.z.boolean().default(false),
+    yotpo: import_zod11.z.boolean().default(false)
+  }),
+  key: import_zod11.z.string().optional(),
+  language: import_zod11.z.object({
+    description: import_zod11.z.union([import_zod11.z.string(), import_zod11.z.unknown().transform(() => "")]).default(""),
+    descriptionEnabled: import_zod11.z.boolean().optional().default(false),
+    descriptionRte: import_zod11.z.object({
+      content: import_zod11.z.array(import_zod11.z.unknown()),
+      type: import_zod11.z.string()
+    }).optional(),
+    descriptionSpacing: import_zod11.z.enum(["none", "xtight", "tight", "default", "loose", "xloose"]).optional(),
+    displayCtaPrice: import_zod11.z.boolean().default(true),
+    global: import_zod11.z.object({
+      declineAll: import_zod11.z.string().optional().default("Decline All"),
+      declineThisOffer: import_zod11.z.string().default("Decline this offer"),
+      free: import_zod11.z.string().optional().default("Free"),
+      notAvailable: import_zod11.z.string().optional().default("Not available"),
+      /** Label for the one-time choice beside `subscriptionOption` in the purchase-type selector */
+      oneTimePurchase: import_zod11.z.string().optional().default("One-time Purchase"),
+      payNow: import_zod11.z.string().default("Pay Now"),
+      payNowUpgradeToSubscription: import_zod11.z.string().optional().default("Upgrade to Subscription"),
+      quantity: import_zod11.z.string().default("Quantity"),
+      /** This isn't configurable in the admin-nextjs editor */
+      recurringShipping: import_zod11.z.string().optional().default("Recurring shipping"),
+      recurringSubtotal: import_zod11.z.string().default("Recurring subtotal"),
+      reviewsPlural: import_zod11.z.string().optional().default("Reviews"),
+      reviewsSingular: import_zod11.z.string().optional().default("Review"),
+      save: import_zod11.z.union([import_zod11.z.string(), import_zod11.z.unknown().transform(() => "Save")]).optional().default("Save"),
+      shipping: import_zod11.z.string().default("Shipping"),
+      subscriptionOption: import_zod11.z.string().optional().default("Subscribe and Save"),
+      subtotal: import_zod11.z.string().default("Subtotal"),
+      taxes: import_zod11.z.string().default("Taxes"),
+      total: import_zod11.z.string().default("Total")
+    }).optional().default(() => ({
+      declineAll: "Decline All",
+      declineThisOffer: "Decline this offer",
+      free: "Free",
+      notAvailable: "Not available",
+      oneTimePurchase: "One-time Purchase",
+      payNow: "Pay Now",
+      payNowUpgradeToSubscription: "Upgrade to Subscription",
+      quantity: "Quantity",
+      /** This isn't configurable in the admin-nextjs editor */
+      recurringShipping: "Recurring shipping",
+      recurringSubtotal: "Recurring subtotal",
+      reviewsPlural: "Reviews",
+      reviewsSingular: "Review",
+      save: "Save",
+      shipping: "Shipping",
+      subscriptionOption: "Subscribe and Save",
+      subtotal: "Subtotal",
+      taxes: "Taxes",
+      total: "Total"
+    })),
+    globalTranslation: import_zod11.z.string().optional().default("english")
+  }),
+  metafields: import_zod11.z.boolean().default(false),
+  /** This isn't configurable in the admin-nextjs editor */
+  offer: import_zod11.z.object({
+    count: import_zod11.z.number().default(1)
+  }),
+  offersLayout: import_zod11.z.object({
+    itemsPerPage: import_zod11.z.number().optional(),
+    type: import_zod11.z.enum(["list", "grid", "carousel"]).default("list")
+  }).optional().default({
+    type: "list"
+  }),
+  /** This isn't configurable in the admin-nextjs editor */
+  previewMode: import_zod11.z.boolean().default(false),
+  productLimit: import_zod11.z.number().optional().default(1),
+  productOptions: import_zod11.z.object({
+    /** This isn't configurable in the admin-nextjs editor */
+    hideOutOfStockVariants: import_zod11.z.boolean().optional().default(false),
+    matchVariant: import_zod11.z.boolean().optional().default(true),
+    showDeclineAll: import_zod11.z.enum(["above", "below", "both", "none"]).optional(),
+    showShipping: import_zod11.z.boolean().optional().default(true),
+    showSubtotal: import_zod11.z.boolean().optional().default(true),
+    showTaxes: import_zod11.z.boolean().optional().default(true),
+    showTotal: import_zod11.z.boolean().optional().default(true),
+    showVariantSelectors: import_zod11.z.boolean().optional().default(true),
+    variantSelectorDisplayMode: import_zod11.z.enum(["separate", "single"]).optional().default("separate")
+  }),
+  productType: import_zod11.z.union([import_zod11.z.enum(["one-time", "subscription", "both"]), import_zod11.z.literal("").transform(() => "one-time")]).default("one-time"),
+  productTypeSelector: import_zod11.z.enum(["dropdown", "radio"]).optional().default("radio"),
+  quantityInputs: import_zod11.z.object({
+    defaultQuantity: import_zod11.z.union([import_zod11.z.number(), import_zod11.z.null().transform(() => 1)]).default(1),
+    enabled: import_zod11.z.boolean().default(true),
+    maxValue: import_zod11.z.union([import_zod11.z.number(), import_zod11.z.null().transform(() => 15)]).default(15),
+    minValue: import_zod11.z.union([import_zod11.z.number().min(0), import_zod11.z.unknown().transform(() => 0)]).default(1)
+  }),
+  shipping: import_zod11.z.object({
+    amount: strictNumber.default(10),
+    /** This isn't configurable in the admin-nextjs editor */
+    enabled: import_zod11.z.boolean().default(true),
+    title: import_zod11.z.string().optional().default("Shipping Fees"),
+    type: import_zod11.z.enum(["free", "fixed_amount"]).default("free")
+  }),
+  styles: import_zod11.z.object({
+    starColor: import_zod11.z.string().optional().default("#fadb14"),
+    starSize: import_zod11.z.union([import_zod11.z.enum(["small", "medium", "large"]), import_zod11.z.unknown().transform(() => "large")]).optional().default("large"),
+    starStrokeColor: import_zod11.z.string().optional().default("#fadb14"),
+    strokeWidth: import_zod11.z.string().optional().default("1")
+  }).optional(),
+  subImages: import_zod11.z.number().nullish().default(8),
+  subscription: import_zod11.z.object({
+    discount: import_zod11.z.object({
+      amount: strictNumber.default(30),
+      shouldShowSavingText: import_zod11.z.boolean().optional().default(true),
+      type: import_zod11.z.enum(["none", "fixed_amount", "percentage"]).default("none")
+    }),
+    shipping: import_zod11.z.object({
+      amount: strictNumber.default(1),
+      /** This isn't configurable in the admin-nextjs editor */
+      enabled: import_zod11.z.boolean().default(true),
+      /** This isn't configurable in the admin-nextjs editor */
+      recurringAmount: strictNumber.default(2),
+      shippingTitle: import_zod11.z.string().default("Shipping Fees"),
+      type: import_zod11.z.enum(["free", "fixed_amount"]).default("free")
+    })
+  }).optional().default({
+    discount: {
+      amount: 30,
+      shouldShowSavingText: true,
+      type: "none"
+    },
+    shipping: {
+      amount: 1,
+      /** This isn't configurable in the admin-nextjs editor */
+      enabled: true,
+      /** This isn't configurable in the admin-nextjs editor */
+      recurringAmount: 2,
+      shippingTitle: "Shipping Fees",
+      type: "free"
+    }
+  }),
+  subscriptionIsDefault: import_zod11.z.boolean().optional(),
+  /** This isn't configurable in the admin-nextjs editor */
+  template: import_zod11.z.string().optional().default(""),
+  type: import_zod11.z.literal("shopify_post_purchase_extension").default("shopify_post_purchase_extension"),
+  upgradeToSubscription: import_zod11.z.object({
+    acceptButtonText: import_zod11.z.string().optional().default("Upgrade"),
+    allow: import_zod11.z.boolean().optional().default(false),
+    emailRefundNotice: import_zod11.z.boolean().optional().default(false),
+    errorBannerText: import_zod11.z.string().optional().default("This subscription cannot be added - limit one per order")
+  }).optional().default(() => ({
+    acceptButtonText: "Upgrade",
+    allow: false,
+    emailRefundNotice: false,
+    errorBannerText: "This subscription cannot be added - limit one per order"
+  }))
+});
+
+// src/schema/postPurchaseProductReviews.ts
+var decimal = import_zod12.z.union([
+  import_zod12.z.number(),
+  import_zod12.z.string().regex(/^\d+(?:\.\d+)?$/).transform(Number)
+]);
+var PostPurchaseCommonReviewRating = import_zod12.z.object({ value: decimal.pipe(import_zod12.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_zod12.z.unknown().nonoptional(),
+  scale_min: import_zod12.z.unknown().nonoptional()
+});
+var PostPurchaseReviewCount = import_zod12.z.string().regex(/^\d+(?:\.\d+)?$/).transform(Number).pipe(import_zod12.z.number().int().nonnegative());
+var PostPurchaseReviewStyles = PostPurchaseSettings.shape.styles.unwrap().extend({
+  strokeWidth: decimal.pipe(import_zod12.z.number().nonnegative()).default(1)
+}).prefault({});
+var PostPurchaseProductReviews = import_zod12.z.object({
+  color: import_zod12.z.string(),
+  rating: import_zod12.z.number().positive().max(5),
+  reviewCount: import_zod12.z.number().int().nonnegative(),
+  reviewsPlural: import_zod12.z.string(),
+  reviewsSingular: import_zod12.z.string(),
+  size: import_zod12.z.enum(["small", "medium", "large"]),
+  strokeColor: import_zod12.z.string(),
+  strokeWidth: import_zod12.z.number().nonnegative()
+});
+
+// src/server/postPurchaseJudgeMeReviews.ts
+var import_zod14 = require("zod");
+
+// src/server/postPurchaseReviewFields.ts
+var import_zod13 = require("zod");
+var Field = import_zod13.z.object({ key: import_zod13.z.string(), namespace: import_zod13.z.string(), value: import_zod13.z.unknown().optional() });
+var reviewFields = (raw) => {
+  const fields4 = import_zod13.z.array(import_zod13.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);
+};
+var ReviewFieldError = class extends Error {
+  constructor(field) {
+    super(`Unreadable review field ${field}`);
+    this.field = field;
+  }
+};
+var readReviewField = (field, read) => {
+  try {
+    return read(field.value);
+  } catch {
+    throw new ReviewFieldError(`${field.namespace}.${field.key}`);
+  }
+};
+
+// src/server/postPurchaseJudgeMeReviews.ts
+var readJudgeMeReviews = (find) => {
+  const field = find("judgeme", "badge");
+  if (!field) return null;
+  return readReviewField(field, (value) => {
+    const html = import_zod14.z.string().parse(value);
+    const rating = html.match(/data-average-rating=['"](\d+(?:\.\d+)?)['"]/);
+    const count = html.match(/data-number-of-reviews=['"](\d+)['"]/);
+    if (!rating || !count) throw new Error("Unreadable Judge.me attributes");
+    return {
+      rating: PostPurchaseCommonReviewRating.parse({ value: rating[1] }).value,
+      reviewCount: PostPurchaseReviewCount.parse(count[1])
+    };
+  });
+};
+
+// src/server/postPurchaseOkendoReviews.ts
+var import_zod15 = require("zod");
+var Summary = import_zod15.z.object({
+  reviewAverageValue: PostPurchaseCommonReviewRating.shape.value,
+  reviewCount: import_zod15.z.union([PostPurchaseProductReviews.shape.reviewCount, PostPurchaseReviewCount])
+});
+var readOkendoReviews = (find) => {
+  const field = find("okendo", "summaryData");
+  if (!field) return null;
+  const summary = readReviewField(field, (value) => Summary.parse(JSON.parse(import_zod15.z.string().parse(value))));
+  return { rating: summary.reviewAverageValue, reviewCount: summary.reviewCount };
+};
+
+// src/server/postPurchaseScalarReviews.ts
+var import_zod16 = 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: readReviewField(
+      rating,
+      (value) => PostPurchaseCommonReviewRating.parse({ value: import_zod16.z.string().parse(value) }).value
+    ),
+    reviewCount: readReviewField(count, (value) => PostPurchaseReviewCount.parse(value))
+  };
+};
+
+// src/server/postPurchaseReviewData.ts
+var readStandardReviews = (find) => {
+  const rating = find("reviews", "rating");
+  const count = find("reviews", "rating_count");
+  if (!rating || !count) return null;
+  return {
+    rating: readReviewField(rating, (raw) => {
+      const value = import_zod17.z.string().parse(raw);
+      return PostPurchaseCommonReviewRating.parse(/^\d+(?:\.\d+)?$/.test(value) ? { value } : JSON.parse(value)).value;
+    }),
+    reviewCount: readReviewField(count, (value) => PostPurchaseReviewCount.parse(value))
+  };
+};
+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") ?? readStandardReviews(find);
+  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: readReviewField(
+      rating,
+      (value) => PostPurchaseKlaviyoReviewRating.parse(JSON.parse(import_zod17.z.string().parse(value))).value
+    ),
+    reviewCount: readReviewField(count, (value) => PostPurchaseReviewCount.parse(value))
+  };
+};
+
+// src/server/postPurchaseReviewProvider.ts
+var import_zod18 = require("zod");
+var IntegrationInput = import_zod18.z.record(import_zod18.z.string(), import_zod18.z.unknown()).prefault({});
+var precedence = [
+  "klaviyo",
+  "judgeme",
+  "junip",
+  "loox",
+  "okendo",
+  "opinew",
+  "reviewsio",
+  "stamped",
+  "yotpo"
+];
+var ReviewsIoFlag = import_zod18.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/offerProductReviews.ts
+var readOrReport = (read, productId2, report) => {
+  try {
+    return read();
+  } catch (error) {
+    if (!(error instanceof ReviewFieldError)) throw error;
+    report?.({
+      detail: "Unreadable offer product reviews metafield",
+      field: error.field,
+      kind: "reviews",
+      productId: productId2
+    });
+    return null;
+  }
+};
+var readReviews = (provider, find, productId2, report) => (provider === "klaviyo" ? null : readOrReport(() => readPostPurchaseReviewData(provider, find), productId2, report)) ?? readOrReport(() => readStandardReviews(find), productId2, report);
+var projectOfferProductReviews = (integrations, { id: productId2, metafields }, report) => {
+  let provider;
+  try {
+    provider = selectPostPurchaseReviewProvider(integrations);
+  } catch {
+    return void 0;
+  }
+  if (!provider) return void 0;
+  try {
+    if (!Array.isArray(metafields)) return null;
+    const data = readReviews(provider, reviewFields(metafields), productId2, report);
+    return data && data.rating > 0 ? data : null;
+  } catch {
+    report?.({ detail: "Unreadable offer product reviews", kind: "product" });
+    return null;
+  }
+};
+
+// src/server/shopSubtotal.ts
+var shopCurrencyRate = (cart) => {
+  const rate = cart.currencyRate ?? 1;
+  return Number.isFinite(rate) && rate > 0 ? rate : 1;
+};
+var shopSubtotalCents = (cart) => Math.round((cart.subtotal - (cart.discountTotal ?? 0)) / shopCurrencyRate(cart));
+var toShopCents = (majorPresentment, rate) => Math.round(majorPresentment * 100 / rate);
+
+// src/schema/cabShopConfig.ts
+var import_zod20 = require("zod");
+
+// src/schema/driftedMarkets.ts
+var DRIFTED_MARKETS = Object.freeze({ enabled: false });
+
+// src/schema/smartCart.ts
+var import_zod19 = require("zod");
+var SmartCartTierProduct = import_zod19.z.looseObject({
+  handle: import_zod19.z.string().optional(),
+  id: import_zod19.z.coerce.number().optional(),
+  productId: import_zod19.z.coerce.number().optional(),
+  title: import_zod19.z.string().optional(),
+  variantIds: import_zod19.z.array(import_zod19.z.coerce.number()).optional()
+});
+var SmartCartTierExclusion = import_zod19.z.looseObject({
+  collectionIds: import_zod19.z.array(import_zod19.z.coerce.number()).optional().catch(void 0),
+  productIds: import_zod19.z.array(import_zod19.z.coerce.number()).optional().catch(void 0),
+  tags: import_zod19.z.array(import_zod19.z.string()).optional().catch(void 0),
+  type: import_zod19.z.string().optional().catch(void 0)
+});
+var SmartCartTier = import_zod19.z.looseObject({
+  allProducts: import_zod19.z.array(SmartCartTierProduct).optional(),
+  /** Merchant-set tier label (e.g. "Free gift", "$100 reward"), shown on the step row when enabled. */
+  customTierLabel: import_zod19.z.boolean().optional(),
+  customTierLabelText: import_zod19.z.string().optional(),
+  decorativeAmountReachedLabel: import_zod19.z.boolean().optional(),
+  decorativeAmountReachedLabelText: import_zod19.z.string().optional(),
+  decorativeAmountRemainingLabel: import_zod19.z.boolean().optional(),
+  decorativeAmountRemainingLabelText: import_zod19.z.string().optional(),
+  /** Order-discount reward: `'fixedAmount'` (shop-currency dollars) or `'percentage'` (whole percent). */
+  discountAmountFromTotal: import_zod19.z.coerce.number().optional(),
+  discountAmountReachedLabel: import_zod19.z.boolean().optional(),
+  discountAmountReachedLabelText: import_zod19.z.string().optional(),
+  discountAmountRemainingLabel: import_zod19.z.boolean().optional(),
+  discountAmountRemainingLabelText: import_zod19.z.string().optional(),
+  discountType: import_zod19.z.string().optional(),
+  /**
+   * onsite `exclusions` + `exclusions_enabled` (REB-22305): per-tier rules the converter carries onto
+   * `CABProgressTier.exclusions`. `.catch(undefined)` for the same blast-radius reason as `productTierImage`:
+   * one drifted value must degrade to "no tier exclusions", never drop every progress bar for the shop.
+   *
+   * `exclusionsEnabled` is a STRICT boolean on purpose, even though failing open here changes the tier's math
+   * (a non-boolean reads as disabled) rather than just an icon. onsite reads its sibling tier flags strictly —
+   * `shouldFilterOutOfStockVariantsFromTier` is `tier?.filter_oos_variants === true`, and its `progressBar.ts`
+   * types every tier flag as `boolean` — so a stored `1` / `"1"` / `"true"` is "disabled" on the onsite bar too.
+   * A truthiness preprocess would make CAB exclude where onsite does not: the opposite parity break.
+   */
+  exclusions: import_zod19.z.array(SmartCartTierExclusion).optional().catch(void 0),
+  exclusionsEnabled: import_zod19.z.boolean().optional().catch(void 0),
+  filterOosVariants: import_zod19.z.boolean().optional(),
+  id: import_zod19.z.string().optional(),
+  /**
+   * A `null`/absent minimum stays `undefined` (NOT coerced to `0`): a threshold-0 tier is always reached
+   * and would auto-add its gift to every cart. onsite's `isTierDataValid` drops a non-numeric minimum for
+   * exactly this reason; the converter's `renderableTiers` mirrors that (`Number.isFinite`). A literal `0`
+   * is kept — onsite keeps it too. DELIBERATE DIVERGENCE from onsite for string minimums: onsite's
+   * `isTierDataValid` is a strict `typeof === 'number'`, so it drops `'50'`; the converter instead coerces
+   * `'50' → 50` and keeps the tier (a numeric-string minimum is a valid threshold, not a data defect).
+   */
+  minimum: import_zod19.z.preprocess((value) => value == null ? void 0 : value, import_zod19.z.coerce.number().optional()),
+  presentmentCurrencies: import_zod19.z.looseObject({ enabled: import_zod19.z.boolean().optional() }).optional(),
+  productAmountReachedLabel: import_zod19.z.boolean().optional(),
+  productAmountReachedLabelText: import_zod19.z.string().optional(),
+  productAmountRemainingLabel: import_zod19.z.boolean().optional(),
+  productAmountRemainingLabelText: import_zod19.z.string().optional(),
+  products: import_zod19.z.array(SmartCartTierProduct).optional(),
+  /**
+   * onsite `product_tier_element_size`: the step-row icon's square size as a px STRING (`'18px'` …
+   * `'36px'` — the admin's five-value Size control, default `'18px'`). React stamps it onto the icon
+   * SVG's `width`/`height` (`getProgressStepIconSize`), so the milestone renders at the merchant's
+   * chosen size; the converter turns it into `CABProgressTier.iconSizePx` for the CAB renderer.
+   *
+   * `.catch(undefined)` for the same blast-radius reason as `productTierImage` below: this key was
+   * previously unknown-and-ignored by the `looseObject`, and `SmartCartConfig` is parsed
+   * `.nullish().catch(undefined)` with no intermediate catch, so one drifted value (a bare number, a
+   * `'2rem'`) would drop EVERY progress bar for the shop rather than just this setting. Failing open to
+   * `undefined` lands on the documented 18px default — strictly safer than that blast radius. The
+   * converter parses the number out and clamps it, so a junk-but-string value degrades the same way.
+   */
+  productTierElementSize: import_zod19.z.string().optional().catch(void 0),
+  /**
+   * onsite `product_tier_image`: on a product (gift) tier, show the gift's product image in the step-row
+   * slot instead of the generic bag icon (React `TierProgressIcon` swaps in the image when this is set and
+   * an image resolves). Per-tier; the client resolves the image (config carries only product IDs).
+   *
+   * `.catch(undefined)` is load-bearing. This key was previously unknown-and-ignored by the `looseObject`;
+   * declaring it as a real boolean means a stored non-boolean (`1` / `"1"` / `"true"`) would now FAIL the
+   * tier — and since `SmartCartConfig` is parsed `.nullish().catch(undefined)` (userConfig/cabShopConfig)
+   * with no intermediate catch, one drifted flag would drop EVERY progress bar for the shop, not just the
+   * flag. The converter only reads it for truthiness (`gift && tier.productTierImage`), so failing open to
+   * `undefined` (bag-icon fallback, the documented default) is strictly safer than that blast radius.
+   */
+  productTierImage: import_zod19.z.boolean().optional().catch(void 0),
+  type: import_zod19.z.string().optional(),
+  /**
+   * onsite's PER-TIER unit switch (`unlock_condition_type`): `'item_quantity'` makes `minimum` an
+   * item count (checked before any money handling — no ×100, no FX, no presentment overrides,
+   * mirroring onsite `getTierMinimum`); anything else (or absent) keeps the money semantics.
+   */
+  unlockConditionType: import_zod19.z.string().optional()
+});
+var SmartCartBar = import_zod19.z.looseObject({
+  countryCodes: import_zod19.z.array(import_zod19.z.string()).optional(),
+  /**
+   * onsite `exclude_discount_in_subtotal`: measure progress against the PRE-discount subtotal so an
+   * applied code/order discount doesn't lower progress. The client adds cart discount allocations back.
+   */
+  excludeDiscountInSubtotal: import_zod19.z.boolean().optional(),
+  /** Products excluded from the progress subtotal; the client subtracts their variants' cart cost. */
+  excludedProducts: import_zod19.z.array(import_zod19.z.looseObject({ variantIds: import_zod19.z.array(import_zod19.z.coerce.number()).optional() })).optional(),
+  freeShippingOnSubscription: import_zod19.z.boolean().optional(),
+  geolocationEnabled: import_zod19.z.boolean().optional(),
+  id: import_zod19.z.string().optional(),
+  language: import_zod19.z.looseObject({
+    freeShippingReached: import_zod19.z.string().optional(),
+    freeShippingRemaining: import_zod19.z.string().optional(),
+    giftAreaTitle: import_zod19.z.string().optional()
+  }).optional(),
+  name: import_zod19.z.string().optional(),
+  tiers: import_zod19.z.array(SmartCartTier).optional()
+});
+var SmartCartComponent = import_zod19.z.looseObject({
+  settings: import_zod19.z.looseObject({ bars: import_zod19.z.array(SmartCartBar).optional() }).optional(),
+  type: import_zod19.z.string().optional()
+});
+var SmartCartConfig = import_zod19.z.looseObject({
+  components: import_zod19.z.array(SmartCartComponent).optional()
+});
+
+// src/schema/cabShopConfig.ts
+var CabActiveExperiment = import_zod20.z.object({
+  data: import_zod20.z.array(
+    import_zod20.z.object({
+      elementId: import_zod20.z.coerce.number(),
+      id: import_zod20.z.coerce.number(),
+      traffic: import_zod20.z.coerce.number()
+    })
+  ),
+  id: import_zod20.z.coerce.number(),
+  placeholderId: import_zod20.z.coerce.number().nullable(),
+  type: import_zod20.z.string()
+});
+var CabShopConfig = import_zod20.z.object({
+  /**
+   * Per-element resilient: parse as `unknown[]` (non-array → `[]`), then keep only the experiments that
+   * validate. A single drifted experiment drops itself instead of `.catch`-ing the WHOLE array to `[]` and
+   * silently disabling every live A/B test fleet-wide.
+   */
+  activeExperiments: import_zod20.z.array(import_zod20.z.unknown()).catch([]).default([]).transform(
+    (experiments) => experiments.flatMap((experiment) => {
+      const result = CabActiveExperiment.safeParse(experiment);
+      return result.success ? [result.data] : [];
+    })
+  ),
+  /**
+   * Only the two fields the smart-cart entitlement gate reads (`shortName`/`isActive`). Per-element
+   * resilient like `activeExperiments`: a drifted package entry degrades to an inert `''`/false one that
+   * matches nothing, so a real active `cart-merchandising` package still gates correctly and a sibling
+   * drift never fails the shared config parse. Note the salvage is fail-CLOSED, not fail-open, for an
+   * entitled v6 shop: a malformed whole array (⇒ `[]`) or an inerted `cart-merchandising` entry (e.g.
+   * `is_active: 1` ⇒ inactive) makes the gate find no active package and drop every bar. That matches
+   * React's "no proof of entitlement ⇒ render null", but it silently removes bars — so the server gate
+   * ({@link file://../server/widgetSettings.ts} `fetchProgressBarContext`) emits a `shopConfig` drift
+   * when it sees the inert-entry sentinel (`shortName === ''`). The whole-array `[]` case leaves no
+   * sentinel and is not separately signalable here.
+   */
+  activePackages: import_zod20.z.array(import_zod20.z.object({ isActive: import_zod20.z.boolean(), shortName: import_zod20.z.string() }).catch({ isActive: false, shortName: "" })).catch([]).default([]),
+  apiKey: import_zod20.z.string(),
+  /** The shop's billing generation; the smart-cart entitlement gate only fires for `'v6'`. Missing/drift ⇒ `null` (fail open, ungated). */
+  billingVersion: import_zod20.z.string().nullable().catch(null).default(null),
+  /**
+   * The shop's rotating cache-buster: `onsite_cache_key` internally — a unix timestamp the engine bumps,
+   * and the edge copy of this config purges, on every widget/settings/theme edit — but serialized on the
+   * wire as `cache_key`, which `deepCamelCase` maps to this field (renaming it `onsiteCacheKey` would
+   * sever the mapping silently; the wire-level assertion in `userConfig.test.ts` is what fails loudly).
+   * Threaded onto the widgets/settings read as `cache_key` so the engine marks the response
+   * immutable-cacheable and the `cached.*` edge serves it fresh-by-URL. The engine sends a numeric
+   * string — coerce — but admit only number/string inputs and constrain to a positive integer: a bare
+   * coercion folds `null`/`''`/`false` to `0` and `true` to `1` — "valid" numbers that would go upstream
+   * as a constant never-rotating buster and pin the edge copy permanently stale. A real key is always a
+   * positive int sent as number or string, so everything else lands on `.catch()` and degrades that read
+   * to un-busted (origin-served — slower, never stale), never a parse fail.
+   */
+  cacheKey: import_zod20.z.union([import_zod20.z.number(), import_zod20.z.string()]).transform((value) => Number(value)).pipe(import_zod20.z.number().int().positive()).optional().catch(void 0),
+  /**
+   * The shop's base-currency ISO code (e.g. `'USD'`). CAB derives the shop minor-unit exponent from it
+   * (`currencyDecimals`) so a Functions-applied fixed discount — whose amount is in shop minor units —
+   * converts to the buyer's currency exactly in a cross-decimal market. `.catch()` like its siblings: a
+   * missing/renamed currency degrades to "unknown" (client falls back to buyer decimals), never a parse fail.
+   */
+  currency: import_zod20.z.string().optional().catch(void 0),
+  /**
+   * The merchant's "Use Markets in Data Sources" toggle. The engine (CI2) never reads it on the serve
+   * path, so the proxy honouring it before sending market context is what makes the setting mean
+   * anything (REB-21688). Fail-CLOSED, unlike the fail-open siblings: a missing/null/drifted field reads
+   * as markets OFF — market context silently dropped (engine serves shop-default market), never sent
+   * against the merchant's setting. The OFF-reading salvages stay distinguishable: missing AND null are
+   * the engine's normal absent vocabulary (`.nullish()`, like `monetize`/`billingVersion`) and read as
+   * the plain default — not drift — while only a drifted SHAPE `.catch`es, to the {@link DRIFTED_MARKETS}
+   * identity sentinel, so `fetchUserConfig` can emit a `shopConfig` drift for the one case that means an
+   * engine rename/retype; otherwise a markets-enabled merchant degrading to shop-default pricing would
+   * be indistinguishable from markets genuinely off. The missing-key case is EXPLICIT via `.default()`
+   * (a factory, so parses never share a mutable object) rather than inferred from zod running an
+   * optional key's transform on `undefined`; `null` flows past the default through `.nullish()` into the
+   * transform. `Readonly` on the output type because the drifted salvage IS frozen — an assignment to
+   * `markets.enabled` downstream would throw only for drifted shops in production, so surface direct
+   * writes to tsc (a guard for the direct case only: TS doesn't check `readonly` in assignability, so
+   * laundering through a mutable-shaped alias still compiles).
+   * The inner `enabled` stays strict on purpose: `{ enabled: null }` is a genuine retype and drifting is
+   * the correct answer (the editor-path `ShopConfig.markets` would hard-fail the same payload).
+   */
+  markets: import_zod20.z.object({ enabled: import_zod20.z.boolean() }).nullish().catch(DRIFTED_MARKETS).default(() => ({ enabled: false })).transform((markets) => markets ?? { enabled: false }),
+  monetize: import_zod20.z.object({ publisherKey: import_zod20.z.string().nullable() }).nullish().catch(void 0),
+  shopId: import_zod20.z.number().optional().catch(void 0),
+  /**
+   * The merchant's display name ("Gift Basket Store") — the Monetize header copy reads it.
+   * `.catch()` like its siblings: a missing/drifted name degrades the header to the
+   * myshopify-domain slug (the pre-CAB React fallback), never a parse fail. An empty string is a
+   * VALID parse — the slug fallback for `''` (and whitespace/tag-only names) lives in
+   * composeOffer's `||` chain, not here.
+   */
+  shopName: import_zod20.z.string().nullish().catch(void 0)
+});
+var CabUserConfig = import_zod20.z.object({
+  shop: CabShopConfig,
+  smartCart: SmartCartConfig.nullish().catch(void 0)
+});
+
+// src/schema/widgets/checkout-and-beyond/image.ts
+var import_uuid14 = require("uuid");
+var import_zod39 = require("zod");
+
+// src/schema/widgets/checkout-and-beyond/icons.ts
+var iconNames = [
+  "alert-circle",
+  "alert-triangle",
+  "alert-triangle-filled",
+  "arrow-down",
+  "arrow-left",
+  "arrow-right",
+  "arrow-up",
+  "arrow-up-right",
+  "bag",
+  "bullet",
+  "calendar",
+  "camera",
+  "caret-down",
+  "cart",
+  "cash-dollar",
+  "categories",
+  "check",
+  "check-circle",
+  "check-circle-filled",
+  "chevron-down",
+  "chevron-left",
+  "chevron-right",
+  "chevron-up",
+  "circle",
+  "clipboard",
+  "clock",
   "credit-card",
   "delete",
   "delivered",
@@ -992,283 +1872,65 @@ var iconTones = ["auto", "critical", "custom", "info", "neutral", "success", "wa
 var IconTone = freezeEnum(iconTones);
 
 // src/schema/widgets/checkout-and-beyond/imageThumbnails.ts
-var import_zod7 = require("zod");
-var CABImageThumbnails = import_zod7.z.object({
-  limit: import_zod7.z.number().int().min(1).default(8),
-  perLine: import_zod7.z.number().int().min(1).max(8).default(4)
-});
-
-// src/schema/widgets/checkout-and-beyond/regex.ts
-var DYNAMIC_TOKEN_REGEX = /^\{\{\s*[A-Za-z]+\s*\}\}$/;
-var HEX_COLOR_REGEX = /^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/;
-var ROOT_RELATIVE_PATH_REGEX = /^\/(?!\/)/;
-var HTML_TAGS_REGEX = /<\/?[a-zA-Z][^>]*>/g;
+var import_zod21 = require("zod");
+var CABImageThumbnails = import_zod21.z.object({
+  limit: import_zod21.z.number().int().min(1).default(8),
+  perLine: import_zod21.z.number().int().min(1).max(8).default(4)
+});
 
 // src/schema/widgets/checkout-and-beyond/shared.ts
-var import_zod27 = require("zod");
+var import_zod38 = require("zod");
 
 // src/schema/widgets/checkout-and-beyond/banner.ts
-var import_zod11 = require("zod");
-
-// src/schema/widgets/checkout-and-beyond/layout.ts
-var import_uuid = require("uuid");
-var import_zod10 = require("zod");
-
-// src/schema/widgets/checkout-and-beyond/variables.ts
-var import_zod9 = require("zod");
-
-// src/schema/widgets/checkout-and-beyond/rule.ts
-var import_zod8 = require("zod");
-var ruleTypes = [
-  "cart",
-  "cart_count",
-  "cart_item_count",
-  "cart_line_count",
-  "cart_subtotal",
-  "collection",
-  "customer",
-  "customer_order_count",
-  "customer_tag",
-  "customer_total_spent",
-  "date",
-  "product",
-  "product_tag",
-  "product_title",
-  "product_type",
-  "product_vendor"
-];
-var ruleType = import_zod8.z.enum(ruleTypes);
-var RuleType = ruleType.enum;
-var ruleOperators = [
-  "after",
-  "anything",
-  "before",
-  "contains",
-  "contains_any",
-  "does_not_contain",
-  "does_not_contain_any",
-  "equals",
-  "does_not_equal",
-  "greater_than",
-  "less_than"
-];
-var ruleOperator = import_zod8.z.enum(ruleOperators);
-var RuleOperator = ruleOperator.enum;
-var RuleCondition = import_zod8.z.object({
-  operator: import_zod8.z.enum(ruleOperators).default(RuleOperator.anything),
-  products: import_zod8.z.union([import_zod8.z.array(import_zod8.z.unknown()), import_zod8.z.strictObject({}).transform(() => [])]).default(() => []),
-  type: import_zod8.z.enum(ruleTypes).default(RuleType.cart_subtotal),
-  value: import_zod8.z.coerce.string().default("")
-});
-var RuleLogicBlock = import_zod8.z.object({
-  rules: import_zod8.z.array(RuleCondition).default(() => [])
-});
-var CABRulesetEntry = import_zod8.z.object({
-  exitIfMatched: import_zod8.z.boolean().default(true),
-  logic: import_zod8.z.array(RuleLogicBlock).default(() => []),
-  output: import_zod8.z.array(
-    import_zod8.z.object({
-      key: import_zod8.z.string().default("should_show"),
-      type: import_zod8.z.literal("data_json").default("data_json"),
-      value: import_zod8.z.string().default("true")
-    })
-  ).default(() => [{ key: "should_show", type: "data_json", value: "true" }])
-});
-var CABRuleset = import_zod8.z.union([import_zod8.z.array(CABRulesetEntry), import_zod8.z.strictObject({}).transform(() => [])]).default(() => []);
-
-// src/schema/widgets/checkout-and-beyond/variables.ts
-var variableEffect = import_zod9.z.enum(variableEffects);
-var CABVariableSeed = import_zod9.z.object({
-  dataSourceId: import_zod9.z.number().nullable().default(null),
-  ruleset: CABRuleset
-});
-var CABBooleanVariable = import_zod9.z.object({
-  /**
-   * Holds until the first seed verdict lands (and forever, for unseeded variables). Omitted, it derives
-   * from seededness — `false` with a `seed` (visibility is EARNED), `true` without — via the transform
-   * below; a cross-field default has no `.default()` spelling. An explicit value always wins.
-   */
-  defaultValue: import_zod9.z.boolean().optional(),
-  name: import_zod9.z.string().min(1),
-  seed: CABVariableSeed.optional(),
-  /** Defaulted so every stored declaration (all boolean before `text` existed) parses unchanged. */
-  type: import_zod9.z.literal(VariableType.boolean).default(VariableType.boolean)
-});
-var CABTextVariable = import_zod9.z.object({
-  defaultValue: import_zod9.z.string(),
-  name: import_zod9.z.string().min(1),
-  seed: import_zod9.z.never().optional(),
-  type: import_zod9.z.literal(VariableType.text)
-});
-var CABNumberVariable = import_zod9.z.object({
-  defaultValue: import_zod9.z.number(),
-  name: import_zod9.z.string().min(1),
-  seed: import_zod9.z.never().optional(),
-  type: import_zod9.z.literal(VariableType.number)
-});
-var CABVariable = import_zod9.z.union([CABTextVariable, CABNumberVariable, CABBooleanVariable]).transform(
-  (variable) => variable.type === VariableType.boolean ? { ...variable, defaultValue: variable.defaultValue ?? variable.seed === void 0 } : variable
-);
-var CABVariableEffect = import_zod9.z.object({
-  effect: variableEffect.default(VariableEffect.toggle),
-  variable: import_zod9.z.string().min(1)
-});
-var CABVisibility = import_zod9.z.object({
-  variable: import_zod9.z.string().min(1),
-  visibleWhen: import_zod9.z.boolean().default(true)
-});
-var contentOperator = import_zod9.z.enum(contentOperators);
-var resultCountOperator = import_zod9.z.enum(resultCountOperators);
-var resultTagOperator = import_zod9.z.enum(resultTagOperators);
-var mutatorEvent = import_zod9.z.enum(mutatorEvents);
-var CABContentTrigger = import_zod9.z.object({
-  operator: contentOperator.default(ContentOperator.is_empty),
-  type: import_zod9.z.literal("content")
-});
-var CABResultCountTrigger = import_zod9.z.object({
-  operator: resultCountOperator.default(ResultCountOperator.equals),
-  type: import_zod9.z.literal("result_count"),
-  value: import_zod9.z.number().default(0)
-});
-var CABResultTagTrigger = import_zod9.z.object({
-  operator: resultTagOperator.default(ResultTagOperator.contains),
-  type: import_zod9.z.literal("result_tag"),
-  value: import_zod9.z.string().min(1)
-});
-var CABEventTrigger = import_zod9.z.object({
-  event: mutatorEvent,
-  type: import_zod9.z.literal("event")
-});
-var CABVariableTrigger = import_zod9.z.discriminatedUnion("type", [
-  CABContentTrigger,
-  CABEventTrigger,
-  CABResultCountTrigger,
-  CABResultTagTrigger
-]);
-var CABVariableMutator = import_zod9.z.object({
-  effect: variableEffect.default(VariableEffect.set_false),
-  variable: import_zod9.z.string().min(1),
-  when: CABVariableTrigger
-});
-var CABVariableFields = {
-  mutators: import_zod9.z.array(CABVariableMutator).optional(),
-  variables: import_zod9.z.array(CABVariable).refine((variables) => new Set(variables.map(({ name }) => name)).size === variables.length, {
-    message: "variable names must be unique within a section"
-  }).optional(),
-  visibility: CABVisibility.optional()
-};
+var import_zod23 = require("zod");
 
 // src/schema/widgets/checkout-and-beyond/layout.ts
-var GridItem = import_zod10.z.union([import_zod10.z.literal("auto"), import_zod10.z.literal("fill"), import_zod10.z.string().regex(/^\d+%$/), import_zod10.z.number()]);
-var CABLayoutWrapping = import_zod10.z.object({
-  breakAt: import_zod10.z.number().positive(),
-  maxPerLine: import_zod10.z.number().int().positive()
+var import_uuid3 = require("uuid");
+var import_zod22 = require("zod");
+var GridItem = import_zod22.z.union([import_zod22.z.literal("auto"), import_zod22.z.literal("fill"), import_zod22.z.string().regex(/^\d+%$/), import_zod22.z.number()]);
+var CABLayoutWrapping = import_zod22.z.object({
+  breakAt: import_zod22.z.number().positive(),
+  maxPerLine: import_zod22.z.number().int().positive()
 });
-var CABLayoutSection = import_zod10.z.object({
+var CABLayoutSection = import_zod22.z.object({
   ...CABVariableFields,
-  alignment: import_zod10.z.object({
-    horizontal: import_zod10.z.enum(horizontalAlignments).default(HorizontalAlignment.start),
-    vertical: import_zod10.z.enum(verticalAlignments).default(VerticalAlignment.top)
+  alignment: import_zod22.z.object({
+    horizontal: import_zod22.z.enum(horizontalAlignments).default(HorizontalAlignment.start),
+    vertical: import_zod22.z.enum(verticalAlignments).default(VerticalAlignment.top)
   }).default({
     horizontal: HorizontalAlignment.start,
     vertical: VerticalAlignment.top
   }),
-  border: import_zod10.z.lazy(() => CABBorder),
-  buttonField: import_zod10.z.enum(buttonFields).optional(),
-  direction: import_zod10.z.enum(directions).default(Direction.rows),
+  border: import_zod22.z.lazy(() => CABBorder),
+  buttonField: import_zod22.z.enum(buttonFields).optional(),
+  direction: import_zod22.z.enum(directions).default(Direction.rows),
   /**
    * Platform chrome around the section, not a layout behavior: `callout` is a subdued box with block borders
    * (the legacy post-purchase callout banner), `offer-content` the post-purchase offer's own content card.
    */
-  frame: import_zod10.z.enum(layoutFrames).optional(),
-  grid: import_zod10.z.object({
-    columns: import_zod10.z.union([import_zod10.z.array(GridItem), import_zod10.z.undefined()]).default(() => ["auto"]),
-    rows: import_zod10.z.union([import_zod10.z.array(GridItem), import_zod10.z.undefined()]).default(() => ["auto"])
+  frame: import_zod22.z.enum(layoutFrames).optional(),
+  grid: import_zod22.z.object({
+    columns: import_zod22.z.union([import_zod22.z.array(GridItem), import_zod22.z.undefined()]).default(() => ["auto"]),
+    rows: import_zod22.z.union([import_zod22.z.array(GridItem), import_zod22.z.undefined()]).default(() => ["auto"])
   }).default({ columns: ["auto"], rows: ["auto"] }).optional(),
-  name: import_zod10.z.string().optional(),
-  padding: import_zod10.z.enum(spacings).default(Spacing.none),
-  sectionId: import_zod10.z.uuid().default(() => (0, import_uuid.v7)()),
-  sections: import_zod10.z.union([import_zod10.z.array(import_zod10.z.lazy(() => CABSection)), import_zod10.z.strictObject({}).transform(() => [])]).default(() => []),
-  sectionType: import_zod10.z.literal(SectionType.layout).default(SectionType.layout),
-  spacing: import_zod10.z.enum(spacings).default(Spacing.base),
+  name: import_zod22.z.string().optional(),
+  padding: import_zod22.z.enum(spacings).default(Spacing.none),
+  sectionId: import_zod22.z.uuid().default(() => (0, import_uuid3.v7)()),
+  sections: import_zod22.z.union([import_zod22.z.array(import_zod22.z.lazy(() => CABSection)), import_zod22.z.strictObject({}).transform(() => [])]).default(() => []),
+  sectionType: import_zod22.z.literal(SectionType.layout).default(SectionType.layout),
+  spacing: import_zod22.z.enum(spacings).default(Spacing.base),
   /** Fire-and-forget impression pixel POSTed once when the section is shown (e.g. a Monetize offer view). */
-  viewUrl: import_zod10.z.string().optional(),
-  width: import_zod10.z.number().default(100),
+  viewUrl: import_zod22.z.string().optional(),
+  width: import_zod22.z.number().default(100),
   wrapping: CABLayoutWrapping.optional()
 });
 
-// src/schema/widgets/checkout-and-beyond/utils.ts
-var import_es_toolkit2 = require("es-toolkit");
-var import_compat = require("es-toolkit/compat");
-
-// src/transforms/convertNumericObjects.ts
-var import_es_toolkit = require("es-toolkit");
-var ARRAY_INDEX_STRING = /^(?:0|[1-9]\d*)$/;
-var hasOnlyNumericKeys = (input, requireCompleteRun) => {
-  const keys = Object.keys(input);
-  if (keys.length === 0) return false;
-  if (!keys.every((key) => ARRAY_INDEX_STRING.test(key) && Number.isSafeInteger(Number(key)))) return false;
-  if (!requireCompleteRun) return true;
-  const sorted = keys.map(Number).sort((a, b) => a - b);
-  return sorted.every((n, i) => n === i);
-};
-var numericObjectToArray = (input) => Object.entries(input).sort(([a], [b]) => Number(a) - Number(b)).map(([, value]) => value);
-var convert = (input, requireCompleteRun) => {
-  if (Array.isArray(input)) return input.map((item) => convert(item, requireCompleteRun));
-  if ((0, import_es_toolkit.isPlainObject)(input)) {
-    if (hasOnlyNumericKeys(input, requireCompleteRun)) {
-      return numericObjectToArray(input).map((item) => convert(item, requireCompleteRun));
-    }
-    const out = {};
-    for (const [key, value] of Object.entries(input)) out[key] = convert(value, requireCompleteRun);
-    return out;
-  }
-  return input;
-};
-var convertNumericObjects = (input) => convert(input, true);
-
-// src/schema/widgets/checkout-and-beyond/utils.ts
-var isHTML = (html = "") => {
-  if (typeof window !== "undefined") {
-    const parser = new DOMParser();
-    const doc = parser.parseFromString(html, "text/html");
-    const hasHTML = (nodeList) => Array.from(nodeList).some((node) => node.nodeType === 1);
-    return hasHTML(doc.body.childNodes) || hasHTML(doc.head.childNodes);
-  }
-  return html.search(HTML_TAGS_REGEX) !== -1;
-};
-var hasHTMLInDoc = (doc) => doc.content.some(({ content = [] }) => content.some(({ text: text2 }) => isHTML(text2)));
-var checkForHTML = (input) => !((0, import_compat.isString)(input) && isHTML(input) || (0, import_es_toolkit2.isPlainObject)(input) && hasHTMLInDoc(input));
-var NO_HTML = { message: "HTML is not supported" };
-var isSectionType = (sectionType) => (section) => (0, import_compat.get)(section, "sectionType") === sectionType;
-var isBannerType = isSectionType(SectionType.banner);
-var isButtonType = isSectionType(SectionType.button);
-var isCarouselType = isSectionType(SectionType.carousel);
-var isCartLineType = isSectionType(SectionType.cartLine);
-var isDataSourceType = isSectionType(
-  SectionType.dataSource
-);
-var isDiscountType = isSectionType(SectionType.discount);
-var isImageType = isSectionType(SectionType.image);
-var isLayoutType = isSectionType(SectionType.layout);
-var isMonetizeType = isSectionType(SectionType.monetize);
-var isOffersType = isSectionType(SectionType.offers);
-var isProductType = isSectionType(SectionType.product);
-var isProductsType = isSectionType(SectionType.products);
-var isProgressBarType = isSectionType(
-  SectionType.progressBar
-);
-var isQuantityType = isSectionType(SectionType.quantity);
-var isReviewsType = isSectionType(SectionType.reviews);
-var isTextType = isSectionType(SectionType.text);
-var isVariantsType = isSectionType(SectionType.variants);
-
 // src/schema/widgets/checkout-and-beyond/banner.ts
-var CABBannerSection = import_zod11.z.lazy(
+var CABBannerSection = import_zod23.z.lazy(
   () => CABLayoutSection.omit({ sectionType: true }).extend({
-    buttonField: import_zod11.z.enum(buttonFields).optional(),
-    color: import_zod11.z.enum(bannerColors).default("info"),
-    dismissible: import_zod11.z.boolean().default(true),
+    buttonField: import_zod23.z.enum(buttonFields).optional(),
+    color: import_zod23.z.enum(bannerColors).default("info"),
+    dismissible: import_zod23.z.boolean().default(true),
     /**
      * The `s-banner` heading — localized content (a buyer can see a merchant-composed banner). Absent OR
      * blank ⇒ no heading; the renderer emits no heading slot for `''` rather than an empty one.
@@ -1284,140 +1946,50 @@ var CABBannerSection = import_zod11.z.lazy(
      * not a 500. Nothing emits `heading` yet; the first converter that maps merchant banner copy into it
      * either strips first or teaches `normalizeTextContent` to strip this field.
      */
-    heading: import_zod11.z.record(import_zod11.z.string(), import_zod11.z.string().refine(checkForHTML, NO_HTML)).optional(),
-    sectionType: import_zod11.z.literal(SectionType.banner).default(SectionType.banner)
+    heading: import_zod23.z.record(import_zod23.z.string(), import_zod23.z.string().refine(checkForHTML, NO_HTML)).optional(),
+    sectionType: import_zod23.z.literal(SectionType.banner).default(SectionType.banner)
   })
 );
 
 // src/schema/widgets/checkout-and-beyond/button.ts
-var import_uuid3 = require("uuid");
-var import_zod13 = require("zod");
-
-// src/schema/widgets/checkout-and-beyond/text.ts
-var import_compat2 = require("es-toolkit/compat");
-var import_uuid2 = require("uuid");
-var import_zod12 = require("zod");
-var enumOrOmit = (...vals) => import_zod12.z.string().transform((val) => vals.includes(val) ? val : void 0).optional();
-var TiptapText = import_zod12.z.object({
-  marks: import_zod12.z.union([
-    import_zod12.z.array(
-      import_zod12.z.discriminatedUnion("type", [
-        import_zod12.z.object({ type: import_zod12.z.literal("bold") }),
-        import_zod12.z.object({ type: import_zod12.z.literal("italic") }),
-        import_zod12.z.object({
-          attrs: import_zod12.z.object({
-            class: import_zod12.z.string().nullable(),
-            href: import_zod12.z.union([
-              import_zod12.z.url(),
-              import_zod12.z.literal("#"),
-              import_zod12.z.string().regex(DYNAMIC_TOKEN_REGEX),
-              import_zod12.z.string().regex(ROOT_RELATIVE_PATH_REGEX)
-            ]),
-            rel: import_zod12.z.string().default("noopener noreferrer nofollow"),
-            target: import_zod12.z.string().default("_blank")
-          }),
-          type: import_zod12.z.literal("link")
-        }),
-        import_zod12.z.object({ type: import_zod12.z.literal("strike") }),
-        import_zod12.z.object({
-          attrs: import_zod12.z.object({
-            color: enumOrOmit(...textColorNames).default(TextColorName.base),
-            fontSize: enumOrOmit(...textSizeNames).default(TextSizeName.base)
-          }),
-          type: import_zod12.z.literal("textStyle")
-        })
-      ])
-    ),
-    import_zod12.z.strictObject({}).transform(() => [])
-  ]).optional(),
-  text: import_zod12.z.string().default(""),
-  type: import_zod12.z.literal("text").default("text")
-});
-var TiptapParagraph = import_zod12.z.object({
-  attrs: import_zod12.z.object({
-    textAlign: enumOrOmit(...textAlignments)
-  }).default({ textAlign: TextAlignment.start }),
-  content: import_zod12.z.union([import_zod12.z.array(TiptapText), import_zod12.z.strictObject({}).transform(() => [])]).default(() => []),
-  type: import_zod12.z.literal("paragraph").default("paragraph")
-});
-var TiptapDocument = import_zod12.z.object({
-  attrs: import_zod12.z.object({
-    blockSpacing: enumOrOmit(...spacings)
-  }).default({ blockSpacing: Spacing.base }),
-  content: import_zod12.z.union([import_zod12.z.array(TiptapParagraph), import_zod12.z.strictObject({}).transform(() => [])]).default(() => [TiptapParagraph.parse({})]),
-  type: import_zod12.z.literal("doc").default("doc")
-});
-var CABTextTier = import_zod12.z.object({
-  threshold: import_zod12.z.number().int().nonnegative(),
-  thresholds: import_zod12.z.record(import_zod12.z.string(), import_zod12.z.number().int().nonnegative()).default(() => ({})),
-  tierId: import_zod12.z.string().optional(),
-  tierType: import_zod12.z.enum(progressTierTypes).default(ProgressTierType.shipping)
-});
-var CABTextSection = import_zod12.z.object({
-  ...CABVariableFields,
-  buttonField: import_zod12.z.enum(buttonFields).optional(),
-  content: import_zod12.z.record(import_zod12.z.string(), import_zod12.z.union([import_zod12.z.string(), TiptapDocument]).refine(checkForHTML, NO_HTML).optional()).default({ en: TiptapDocument.parse({}) }).optional(),
-  name: import_zod12.z.string().optional(),
-  optionId: import_zod12.z.number().optional(),
-  sectionId: import_zod12.z.uuid().default(() => (0, import_uuid2.v7)()),
-  sectionType: import_zod12.z.literal(SectionType.text).default(SectionType.text),
-  tier: CABTextTier.optional()
-}).superRefine(({ buttonField, content }, ctx) => {
-  if (buttonField === ButtonField.destinationUrl && content) {
-    (0, import_compat2.forEach)(content, (value, lang) => {
-      if (value && (0, import_compat2.isString)(value)) {
-        if (DYNAMIC_TOKEN_REGEX.test(value)) return;
-        try {
-          new URL(value);
-        } catch {
-          ctx.addIssue({
-            code: "custom",
-            message: "Invalid URL",
-            path: ["content", lang]
-          });
-        }
-      }
-    });
-  }
-});
-
-// src/schema/widgets/checkout-and-beyond/button.ts
-var CABButtonContent = import_zod13.z.lazy(
-  () => import_zod13.z.discriminatedUnion("sectionType", [CABImageSection, CABLayoutSection, CABTextSection])
+var import_uuid4 = require("uuid");
+var import_zod24 = require("zod");
+var CABButtonContent = import_zod24.z.lazy(
+  () => import_zod24.z.discriminatedUnion("sectionType", [CABImageSection, CABLayoutSection, CABTextSection])
 );
-var CABButtonSection = import_zod13.z.object({
+var CABButtonSection = import_zod24.z.object({
   ...CABVariableFields,
-  action: import_zod13.z.union([import_zod13.z.literal(""), import_zod13.z.enum(buttonActions)]).default(""),
-  buttonStyle: import_zod13.z.enum(buttonStyles).default(ButtonStyle.primary),
-  custom: import_zod13.z.object({
-    color: import_zod13.z.string().regex(HEX_COLOR_REGEX).default("#005bd3"),
-    height: import_zod13.z.number().default(52),
-    width: import_zod13.z.number().default(300)
+  action: import_zod24.z.union([import_zod24.z.literal(""), import_zod24.z.enum(buttonActions)]).default(""),
+  buttonStyle: import_zod24.z.enum(buttonStyles).default(ButtonStyle.primary),
+  custom: import_zod24.z.object({
+    color: import_zod24.z.string().regex(HEX_COLOR_REGEX).default("#005bd3"),
+    height: import_zod24.z.number().default(52),
+    width: import_zod24.z.number().default(300)
   }).default({
     color: "#005bd3",
     height: 52,
     width: 300
   }),
-  disableDowngrade: import_zod13.z.boolean().default(false),
+  disableDowngrade: import_zod24.z.boolean().default(false),
   /**
    * What labels a `switchToSubscription` button's frequency options. `planName` shows the selling plan's
    * own name (legacy post-purchase, L115) and falls back to the `subscriptionOption` template for a plan
    * without one; absent or `template` is the template alone (the checkout card). Optional and additive
    * (REB-24846); an unknown value reads as absent.
    */
-  frequencyLabel: import_zod13.z.enum(["planName", "template"]).optional().catch(void 0),
-  name: import_zod13.z.string().optional(),
-  optionId: import_zod13.z.number().optional(),
-  popover: import_zod13.z.object({
-    alignment: import_zod13.z.enum(textAlignments).default(TextAlignment.center),
-    position: import_zod13.z.enum(popoverPositions).default(PopoverPosition.blockStart)
+  frequencyLabel: import_zod24.z.enum(["planName", "template"]).optional().catch(void 0),
+  name: import_zod24.z.string().optional(),
+  optionId: import_zod24.z.number().optional(),
+  popover: import_zod24.z.object({
+    alignment: import_zod24.z.enum(textAlignments).default(TextAlignment.center),
+    position: import_zod24.z.enum(popoverPositions).default(PopoverPosition.blockStart)
   }).optional().default(() => ({
     alignment: TextAlignment.center,
     position: PopoverPosition.blockStart
   })),
-  sectionId: import_zod13.z.uuid().default(() => (0, import_uuid3.v7)()),
-  sections: import_zod13.z.union([import_zod13.z.array(CABButtonContent), import_zod13.z.strictObject({}).transform(() => [])]).default(() => []),
-  sectionType: import_zod13.z.literal(SectionType.button).default(SectionType.button),
+  sectionId: import_zod24.z.uuid().default(() => (0, import_uuid4.v7)()),
+  sections: import_zod24.z.union([import_zod24.z.array(CABButtonContent), import_zod24.z.strictObject({}).transform(() => [])]).default(() => []),
+  sectionType: import_zod24.z.literal(SectionType.button).default(SectionType.button),
   /**
    * The smart-cart tier this button acts on (`addGift`/`removeGift`): scopes the click to one tier's gift. The
    * client resolves the tier's gift (productId) from the progress-bar context by this `tierId` — the button node
@@ -1432,25 +2004,25 @@ var CABButtonSection = import_zod13.z.object({
    * lookup finds no tier and the click resolves to nothing. Safe to bound — the field is new, so there are no
    * stored payloads to grandfather, and the producer is client code, not a merchant form.
    */
-  tier: import_zod13.z.object({ tierId: import_zod13.z.string().min(1) }).optional(),
+  tier: import_zod24.z.object({ tierId: import_zod24.z.string().min(1) }).optional(),
   /** Fire-and-forget pixel POSTed when the button is clicked (e.g. a Monetize decline). */
-  trackingUrl: import_zod13.z.string().optional(),
+  trackingUrl: import_zod24.z.string().optional(),
   /**
    * Secondary effects applied to in-scope variables on click, alongside (never instead of) the primary
    * `action` — an `addToOrder` button can also flip a variable. Applied in array order.
    */
-  variableEffects: import_zod13.z.array(CABVariableEffect).optional()
+  variableEffects: import_zod24.z.array(CABVariableEffect).optional()
 });
 
 // src/schema/widgets/checkout-and-beyond/carousel.ts
-var import_zod18 = require("zod");
+var import_zod29 = require("zod");
 
 // src/schema/widgets/checkout-and-beyond/offers.ts
-var import_zod17 = require("zod");
+var import_zod28 = require("zod");
 
 // src/schema/widgets/checkout-and-beyond/dataSource.ts
-var import_uuid4 = require("uuid");
-var import_zod14 = require("zod");
+var import_uuid5 = require("uuid");
+var import_zod25 = require("zod");
 
 // src/schema/widgets/checkout-and-beyond/constants.ts
 var import_es_toolkit3 = require("es-toolkit");
@@ -1504,77 +2076,77 @@ var targetAreas = {
 };
 
 // src/schema/widgets/checkout-and-beyond/dataSource.ts
-var CABDiscount = import_zod14.z.object({
-  amount: import_zod14.z.union([import_zod14.z.number(), import_zod14.z.string()]).catch(0),
-  discountedBy: import_zod14.z.string().optional(),
-  discountedFrom: import_zod14.z.enum(discountSources).optional().catch(void 0),
-  type: import_zod14.z.enum(discountTypes).catch("none")
-});
-var CABIntegrations = import_zod14.z.object({
-  judgeme: import_zod14.z.boolean().default(false),
-  junip: import_zod14.z.boolean().default(false),
-  klaviyo: import_zod14.z.boolean().default(false),
-  loox: import_zod14.z.boolean().default(false),
-  okendo: import_zod14.z.boolean().default(false),
-  opinew: import_zod14.z.boolean().default(false),
-  reviewsio: import_zod14.z.boolean().default(false),
-  stamped: import_zod14.z.boolean().default(false),
-  yotpo: import_zod14.z.boolean().default(false)
-});
-var CABVariantLabels = import_zod14.z.object({
-  variantOption: import_zod14.z.string().optional().catch(void 0),
-  variantOptions: import_zod14.z.string().optional().catch(void 0)
-});
-var CABDataSourceSection = import_zod14.z.object({
-  dataSourceId: import_zod14.z.number().nullable().default(null),
-  dataSourcePath: import_zod14.z.string().default(DEFAULT_ENDPOINTS[0].value),
+var CABDiscount = import_zod25.z.object({
+  amount: import_zod25.z.union([import_zod25.z.number(), import_zod25.z.string()]).catch(0),
+  discountedBy: import_zod25.z.string().optional(),
+  discountedFrom: import_zod25.z.enum(discountSources).optional().catch(void 0),
+  type: import_zod25.z.enum(discountTypes).catch("none")
+});
+var CABIntegrations = import_zod25.z.object({
+  judgeme: import_zod25.z.boolean().default(false),
+  junip: import_zod25.z.boolean().default(false),
+  klaviyo: import_zod25.z.boolean().default(false),
+  loox: import_zod25.z.boolean().default(false),
+  okendo: import_zod25.z.boolean().default(false),
+  opinew: import_zod25.z.boolean().default(false),
+  reviewsio: import_zod25.z.boolean().default(false),
+  stamped: import_zod25.z.boolean().default(false),
+  yotpo: import_zod25.z.boolean().default(false)
+});
+var CABVariantLabels = import_zod25.z.object({
+  variantOption: import_zod25.z.string().optional().catch(void 0),
+  variantOptions: import_zod25.z.string().optional().catch(void 0)
+});
+var CABDataSourceSection = import_zod25.z.object({
+  dataSourceId: import_zod25.z.number().nullable().default(null),
+  dataSourcePath: import_zod25.z.string().default(DEFAULT_ENDPOINTS[0].value),
   discount: CABDiscount.optional(),
   integrations: CABIntegrations.optional(),
-  limit: import_zod14.z.number().default(1),
-  matchVariant: import_zod14.z.boolean().default(false),
-  matchVariantOutOfStock: import_zod14.z.boolean().default(false),
-  name: import_zod14.z.string().default(DEFAULT_ENDPOINTS[0].label),
-  productType: import_zod14.z.enum(productTypes).optional(),
-  sectionId: import_zod14.z.uuid().default(() => (0, import_uuid4.v7)()),
-  sectionType: import_zod14.z.literal(SectionType.dataSource).default(SectionType.dataSource),
+  limit: import_zod25.z.number().default(1),
+  matchVariant: import_zod25.z.boolean().default(false),
+  matchVariantOutOfStock: import_zod25.z.boolean().default(false),
+  name: import_zod25.z.string().default(DEFAULT_ENDPOINTS[0].label),
+  productType: import_zod25.z.enum(productTypes).optional(),
+  sectionId: import_zod25.z.uuid().default(() => (0, import_uuid5.v7)()),
+  sectionType: import_zod25.z.literal(SectionType.dataSource).default(SectionType.dataSource),
   /** Default subscribe-vs-one-time for `productType: both` (legacy `subscription_is_default`). */
-  subscriptionIsDefault: import_zod14.z.boolean().default(false),
-  treatAsGwp: import_zod14.z.boolean().default(false),
+  subscriptionIsDefault: import_zod25.z.boolean().default(false),
+  treatAsGwp: import_zod25.z.boolean().default(false),
   variantLabels: CABVariantLabels.optional().catch(void 0)
 });
 
 // src/schema/widgets/checkout-and-beyond/products.ts
-var import_uuid6 = require("uuid");
-var import_zod16 = require("zod");
+var import_uuid7 = require("uuid");
+var import_zod27 = require("zod");
 
 // src/schema/widgets/checkout-and-beyond/product.ts
-var import_uuid5 = require("uuid");
-var import_zod15 = require("zod");
-var CABVariantContent = import_zod15.z.lazy(
-  () => import_zod15.z.discriminatedUnion("sectionType", [CABButtonSection, CABTextSection])
+var import_uuid6 = require("uuid");
+var import_zod26 = require("zod");
+var CABVariantContent = import_zod26.z.lazy(
+  () => import_zod26.z.discriminatedUnion("sectionType", [CABButtonSection, CABTextSection])
 );
-var CABProductSection = import_zod15.z.object({
+var CABProductSection = import_zod26.z.object({
   ...CABVariableFields,
-  name: import_zod15.z.string().optional(),
-  productId: import_zod15.z.number().nullable().default(null),
-  sectionId: import_zod15.z.uuid().default(() => (0, import_uuid5.v7)()),
-  sections: import_zod15.z.union([import_zod15.z.array(CABVariantContent), import_zod15.z.strictObject({}).transform(() => [])]).default(() => []),
-  sectionType: import_zod15.z.literal(SectionType.product).default(SectionType.product),
-  selectors: import_zod15.z.record(import_zod15.z.string(), import_zod15.z.enum(variantSelectors).default(VariantSelector.menu)).default(() => ({})),
-  variantMode: import_zod15.z.enum(variantModes).default(VariantMode.multiple)
+  name: import_zod26.z.string().optional(),
+  productId: import_zod26.z.number().nullable().default(null),
+  sectionId: import_zod26.z.uuid().default(() => (0, import_uuid6.v7)()),
+  sections: import_zod26.z.union([import_zod26.z.array(CABVariantContent), import_zod26.z.strictObject({}).transform(() => [])]).default(() => []),
+  sectionType: import_zod26.z.literal(SectionType.product).default(SectionType.product),
+  selectors: import_zod26.z.record(import_zod26.z.string(), import_zod26.z.enum(variantSelectors).default(VariantSelector.menu)).default(() => ({})),
+  variantMode: import_zod26.z.enum(variantModes).default(VariantMode.multiple)
 });
 
 // src/schema/widgets/checkout-and-beyond/products.ts
-var CABProductsSection = import_zod16.z.object({
+var CABProductsSection = import_zod27.z.object({
   ...CABVariableFields,
-  name: import_zod16.z.string().optional(),
-  sectionId: import_zod16.z.uuid().default(() => (0, import_uuid6.v7)()),
-  sections: import_zod16.z.union([import_zod16.z.array(import_zod16.z.lazy(() => CABProductSection)), import_zod16.z.strictObject({}).transform(() => [])]).default(() => []),
-  sectionType: import_zod16.z.literal(SectionType.products).default(SectionType.products)
+  name: import_zod27.z.string().optional(),
+  sectionId: import_zod27.z.uuid().default(() => (0, import_uuid7.v7)()),
+  sections: import_zod27.z.union([import_zod27.z.array(import_zod27.z.lazy(() => CABProductSection)), import_zod27.z.strictObject({}).transform(() => [])]).default(() => []),
+  sectionType: import_zod27.z.literal(SectionType.products).default(SectionType.products)
 });
 
 // src/schema/widgets/checkout-and-beyond/offers.ts
-var CABOffersSection = import_zod17.z.lazy(
+var CABOffersSection = import_zod28.z.lazy(
   () => CABLayoutSection.omit({ sections: true, sectionType: true }).extend({
     /**
      * A rule between consecutive cards in the vertical list — legacy checkout-offers' `<Divider />`,
@@ -1582,8 +2154,8 @@ var CABOffersSection = import_zod17.z.lazy(
      * run of products). Optional, not defaulted: only the v1 converter sets it (REB-24265); a
      * hand-built tree keeps React CAB's dividerless rendering.
      */
-    divider: import_zod17.z.boolean().optional(),
-    sections: import_zod17.z.union([import_zod17.z.array(import_zod17.z.lazy(() => CABSection)), import_zod17.z.strictObject({}).transform(() => [])]).default(() => [
+    divider: import_zod28.z.boolean().optional(),
+    sections: import_zod28.z.union([import_zod28.z.array(import_zod28.z.lazy(() => CABSection)), import_zod28.z.strictObject({}).transform(() => [])]).default(() => [
       CABBannerSection.parse({
         buttonField: "undoAddToOrder",
         color: "success",
@@ -1597,77 +2169,77 @@ var CABOffersSection = import_zod17.z.lazy(
       CABDataSourceSection.parse({}),
       CABProductsSection.parse({})
     ]),
-    sectionType: import_zod17.z.literal(SectionType.offers).default(SectionType.offers)
+    sectionType: import_zod28.z.literal(SectionType.offers).default(SectionType.offers)
   })
 );
 
 // src/schema/widgets/checkout-and-beyond/carousel.ts
-var CABCarouselSection = import_zod18.z.lazy(
+var CABCarouselSection = import_zod29.z.lazy(
   () => CABLayoutSection.omit({ sections: true, sectionType: true }).extend({
-    autoAdvanceInterval: import_zod18.z.number().default(0),
-    itemsAtOnce: import_zod18.z.number().min(1).default(1),
+    autoAdvanceInterval: import_zod29.z.number().default(0),
+    itemsAtOnce: import_zod29.z.number().min(1).default(1),
     /** Card arrangement for the offers child (`horizontal` = side-by-side) — NOT the carousel's own `direction`. */
-    offersDirection: import_zod18.z.enum(offersDirections).default("vertical"),
-    sections: import_zod18.z.union([import_zod18.z.array(import_zod18.z.lazy(() => CABSection)), import_zod18.z.strictObject({}).transform(() => [])]).default(() => [CABOffersSection.parse({})]),
-    sectionType: import_zod18.z.literal(SectionType.carousel).default(SectionType.carousel)
+    offersDirection: import_zod29.z.enum(offersDirections).default("vertical"),
+    sections: import_zod29.z.union([import_zod29.z.array(import_zod29.z.lazy(() => CABSection)), import_zod29.z.strictObject({}).transform(() => [])]).default(() => [CABOffersSection.parse({})]),
+    sectionType: import_zod29.z.literal(SectionType.carousel).default(SectionType.carousel)
   })
 );
 
 // src/schema/widgets/checkout-and-beyond/cartLine.ts
-var import_zod19 = require("zod");
-var CABCartLineSection = import_zod19.z.lazy(
+var import_zod30 = require("zod");
+var CABCartLineSection = import_zod30.z.lazy(
   () => CABLayoutSection.omit({ sections: true, sectionType: true }).extend({
-    sections: import_zod19.z.union([import_zod19.z.array(import_zod19.z.lazy(() => CABSection)), import_zod19.z.strictObject({}).transform(() => [])]).default(() => [CABButtonSection.parse({ action: ButtonAction.switchToSubscription })]),
-    sectionType: import_zod19.z.literal(SectionType.cartLine).default(SectionType.cartLine)
+    sections: import_zod30.z.union([import_zod30.z.array(import_zod30.z.lazy(() => CABSection)), import_zod30.z.strictObject({}).transform(() => [])]).default(() => [CABButtonSection.parse({ action: ButtonAction.switchToSubscription })]),
+    sectionType: import_zod30.z.literal(SectionType.cartLine).default(SectionType.cartLine)
   })
 );
 
 // src/schema/widgets/checkout-and-beyond/discount.ts
-var import_uuid7 = require("uuid");
-var import_zod20 = require("zod");
-var CABDiscountSection = import_zod20.z.object({
+var import_uuid8 = require("uuid");
+var import_zod31 = require("zod");
+var CABDiscountSection = import_zod31.z.object({
   ...CABVariableFields,
-  amount: import_zod20.z.union([import_zod20.z.number(), import_zod20.z.string()]).catch(0),
-  discountedBy: import_zod20.z.string().optional(),
-  discountedFrom: import_zod20.z.enum(discountSources).optional().catch(void 0),
-  message: import_zod20.z.string().optional(),
-  name: import_zod20.z.string().optional(),
-  quantity: import_zod20.z.number().default(1),
-  sectionId: import_zod20.z.uuid().default(() => (0, import_uuid7.v7)()),
-  sectionType: import_zod20.z.literal(SectionType.discount).default(SectionType.discount),
-  type: import_zod20.z.enum(discountTypes).catch("none")
+  amount: import_zod31.z.union([import_zod31.z.number(), import_zod31.z.string()]).catch(0),
+  discountedBy: import_zod31.z.string().optional(),
+  discountedFrom: import_zod31.z.enum(discountSources).optional().catch(void 0),
+  message: import_zod31.z.string().optional(),
+  name: import_zod31.z.string().optional(),
+  quantity: import_zod31.z.number().default(1),
+  sectionId: import_zod31.z.uuid().default(() => (0, import_uuid8.v7)()),
+  sectionType: import_zod31.z.literal(SectionType.discount).default(SectionType.discount),
+  type: import_zod31.z.enum(discountTypes).catch("none")
 });
 
 // src/schema/widgets/checkout-and-beyond/monetize.ts
-var import_uuid8 = require("uuid");
-var import_zod21 = require("zod");
-var CABMonetizeAds = import_zod21.z.object({
-  requestId: import_zod21.z.string().optional(),
+var import_uuid9 = require("uuid");
+var import_zod32 = require("zod");
+var CABMonetizeAds = import_zod32.z.object({
+  requestId: import_zod32.z.string().optional(),
   /** Defaulted here, never in the beacon: absence of information is `ads` itself being absent. */
-  testing: import_zod21.z.boolean().default(false)
+  testing: import_zod32.z.boolean().default(false)
 });
-var CABMonetizeSection = import_zod21.z.object({
+var CABMonetizeSection = import_zod32.z.object({
   ...CABVariableFields,
   ads: CABMonetizeAds.optional(),
-  name: import_zod21.z.string().optional(),
+  name: import_zod32.z.string().optional(),
   /**
    * Server-hydrated offer cards (inline hydration): when `/cab/sections` was asked with a `monetize`
    * context block, the composed cards ride the marker itself — `[]` means "hydrated, no fill" (render
    * nothing, skip the fetch); ABSENT means "not hydrated" (the client fetches via `/cab/monetize`).
    */
-  offers: import_zod21.z.array(import_zod21.z.lazy(() => CABSection)).optional(),
+  offers: import_zod32.z.array(import_zod32.z.lazy(() => CABSection)).optional(),
   /** Privacy Policy footer href (the widget's `privacy_policy_url` setting); read server-side for hydration, relayed by the client only on the legacy `/cab/monetize` fallback. */
-  privacyPolicyUrl: import_zod21.z.string().optional(),
-  sectionId: import_zod21.z.uuid().default(() => (0, import_uuid8.v7)()),
-  sectionType: import_zod21.z.literal(SectionType.monetize).default(SectionType.monetize),
+  privacyPolicyUrl: import_zod32.z.string().optional(),
+  sectionId: import_zod32.z.uuid().default(() => (0, import_uuid9.v7)()),
+  sectionType: import_zod32.z.literal(SectionType.monetize).default(SectionType.monetize),
   /** Ads-taxonomy sub-vertical id (the widget's `sub_vertical` setting); paired with `vertical`. */
-  subVertical: import_zod21.z.string().optional(),
+  subVertical: import_zod32.z.string().optional(),
   /** Ads-taxonomy vertical id (the widget's `vertical` setting) — with `subVertical`, the admin Monetize editor's two configurables. */
-  vertical: import_zod21.z.string().optional()
+  vertical: import_zod32.z.string().optional()
 });
 
 // src/schema/widgets/checkout-and-beyond/progressBar.ts
-var import_zod22 = require("zod");
+var import_zod33 = require("zod");
 
 // src/schema/widgets/checkout-and-beyond/giftLabels.ts
 var GIFT_LABELS = {
@@ -1786,34 +2358,34 @@ var GIFT_LABELS = {
 };
 
 // src/schema/widgets/checkout-and-beyond/progressBar.ts
-var CABProgressTierExclusion = import_zod22.z.object({
-  collectionIds: import_zod22.z.array(import_zod22.z.number().int().positive()).default(() => []),
-  productIds: import_zod22.z.array(import_zod22.z.number().int().positive()).default(() => []),
-  tags: import_zod22.z.array(import_zod22.z.string().min(1)).default(() => []),
-  type: import_zod22.z.enum(progressTierExclusionTypes)
+var CABProgressTierExclusion = import_zod33.z.object({
+  collectionIds: import_zod33.z.array(import_zod33.z.number().int().positive()).default(() => []),
+  productIds: import_zod33.z.array(import_zod33.z.number().int().positive()).default(() => []),
+  tags: import_zod33.z.array(import_zod33.z.string().min(1)).default(() => []),
+  type: import_zod33.z.enum(progressTierExclusionTypes)
 });
-var CABProgressTier = import_zod22.z.object({
+var CABProgressTier = import_zod33.z.object({
   /**
    * Order-discount tiers only (onsite `discount`): the reward the order-discount Function applies at
    * cart time, carried so the client can resolve the `{{discountAmount}}` token in this tier's copy.
    * `fixedAmount`: shop-currency CENTS (FX-scaled by the client, like {@link CABProgressTier.threshold});
    * `percentage`: the whole-percent number rendered raw (`{n}%`). Absent on non-discount tiers.
    */
-  discount: import_zod22.z.object({ amount: import_zod22.z.number().nonnegative(), type: import_zod22.z.enum(["fixedAmount", "percentage"]) }).optional(),
+  discount: import_zod33.z.object({ amount: import_zod33.z.number().nonnegative(), type: import_zod33.z.enum(["fixedAmount", "percentage"]) }).optional(),
   /**
    * Per-tier exclusion rules (onsite `exclusions` when `exclusions_enabled`): lines they match don't count
    * toward this tier. Empty (the default, and the converter's output for a disabled or ruleless tier) means
    * the tier measures the plain bar-level adjusted progress. Consumers read ONLY the list named by the rule's
    * `type` — the converter leaves the other two at `[]`, so a populated off-type list never reaches the tree.
    */
-  exclusions: import_zod22.z.array(CABProgressTierExclusion).default(() => []),
+  exclusions: import_zod33.z.array(CABProgressTierExclusion).default(() => []),
   /**
    * Smart-cart product (gift) tiers only (onsite `filter_oos_variants`): when set, the client drops this
    * tier entirely once its gift has NO in-stock eligible variant — the milestone, fill slot and gift
    * controls all disappear, mirroring onsite removing the tier from `bar.tiers` before it renders. Absent
    * on shipping/discount/decorative tiers and left off by default (the tier renders regardless of stock).
    */
-  filterOosVariants: import_zod22.z.boolean().default(false),
+  filterOosVariants: import_zod33.z.boolean().default(false),
   /**
    * Smart-cart product (gift) tiers only: the reward unlocked at this tier. The client enriches
    * `productId`/`variantIds` to live variants (availability, price) and adds the chosen one to the cart
@@ -1821,10 +2393,10 @@ var CABProgressTier = import_zod22.z.object({
    * tiers and on tiers with no configured product. Cart add/remove is a later stage; carried here so the
    * tree is complete.
    */
-  gift: import_zod22.z.object({
-    productId: import_zod22.z.number().int().positive(),
-    title: import_zod22.z.string().optional(),
-    variantIds: import_zod22.z.array(import_zod22.z.number().int().positive()).default(() => [])
+  gift: import_zod33.z.object({
+    productId: import_zod33.z.number().int().positive(),
+    title: import_zod33.z.string().optional(),
+    variantIds: import_zod33.z.array(import_zod33.z.number().int().positive()).default(() => [])
   }).optional(),
   /**
    * The step-row icon's square size in PIXELS (onsite `product_tier_element_size`, an admin px string the
@@ -1844,7 +2416,7 @@ var CABProgressTier = import_zod22.z.object({
    * renderer never spells a fallback), which also makes a tree authored before this field render at
    * React's size rather than the old hardcoded 20.
    */
-  iconSizePx: import_zod22.z.number().int().min(1).max(64).default(18),
+  iconSizePx: import_zod33.z.number().int().min(1).max(64).default(18),
   /**
    * The step-row label at this tier's slot (onsite `getTierLabel`): the merchant custom label, else the
    * type default — 'Free Shipping' or '{n}% Discount'. A PRODUCT tier gets NO converter label: its name is
@@ -1854,35 +2426,35 @@ var CABProgressTier = import_zod22.z.object({
    * turns a blank label into an absent key, and a client-authored blank means the same thing — the renderer
    * emits no caption slot rather than an empty one). Plain text — a compact icon+label.
    */
-  label: import_zod22.z.record(import_zod22.z.string(), import_zod22.z.string()).optional(),
+  label: import_zod33.z.record(import_zod33.z.string(), import_zod33.z.string()).optional(),
   /**
    * Smart-cart product (gift) tiers only (onsite `product_tier_image`): show the gift's product image in
    * the step-row slot instead of the generic bag icon. The converter can't supply the image URL (config
    * carries only product IDs), so the client resolves it (authoritative Shopify featured image, React
    * parity) and falls back to the bag icon when the flag is off or no image resolves. Default false.
    */
-  productTierImage: import_zod22.z.boolean().default(false),
+  productTierImage: import_zod33.z.boolean().default(false),
   /**
    * The tier's goal, measured per `unit`. `currency` (default): SHOP-currency cents — the canonical
    * fallback: when the buyer's presentment currency has no entry in `thresholds`, the client
    * multiplies this by the live FX rate (converter maps the v1 `unlock_price`, e.g. `75` → `7500`).
    * `item`: a raw item count — no cents, no FX, no `thresholds` overrides.
    */
-  threshold: import_zod22.z.number().int().nonnegative(),
+  threshold: import_zod33.z.number().int().nonnegative(),
   /**
    * Per-presentment-currency goal overrides — lowercased ISO currency code → cents (e.g. `{ cad: 9900 }`).
    * When the buyer's currency has an entry, the client uses it verbatim INSTEAD of FX-converting
    * `threshold`, so merchants show intentional, clean per-market amounts (Shopify Markets) rather than a
    * converted base. Defaults to `{}` — no overrides means always fall back to `threshold`.
    */
-  thresholds: import_zod22.z.record(import_zod22.z.string(), import_zod22.z.number().int().nonnegative()).default(() => ({})),
+  thresholds: import_zod33.z.record(import_zod33.z.string(), import_zod33.z.number().int().nonnegative()).default(() => ({})),
   /**
    * Smart-cart tier identifier, mirrored onto the gift cart line's `_tier` attribute so the client can
    * match an in-cart gift back to its tier (add on reach, remove on downgrade/decline). Absent on the
    * shipping bar (single unlabeled tier, no gift).
    */
-  tierId: import_zod22.z.string().optional(),
-  tierType: import_zod22.z.enum(progressTierTypes).default(ProgressTierType.shipping),
+  tierId: import_zod33.z.string().optional(),
+  tierType: import_zod33.z.enum(progressTierTypes).default(ProgressTierType.shipping),
   /**
    * What this tier's progress is measured in — PER TIER (onsite's `unlock_condition_type` model, NOT
    * the React port's bar-level `tiers[0]` shortcut). `currency` compares money cents against the
@@ -1893,9 +2465,9 @@ var CABProgressTier = import_zod22.z.object({
    * count carries no injected noun (no English `item`/`items` inflection on localized copy); merchant
    * template text supplies grammatically-neutral wording around the token.
    */
-  unit: import_zod22.z.enum(progressTierUnits).default(ProgressTierUnit.currency)
+  unit: import_zod33.z.enum(progressTierUnits).default(ProgressTierUnit.currency)
 });
-var CABProgressBarSection = import_zod22.z.lazy(
+var CABProgressBarSection = import_zod33.z.lazy(
   () => CABLayoutSection.omit({ sectionType: true }).extend({
     /**
      * The onsite bar id (smart-cart TPB bars only). The client mirrors it to the cart's `_barId` attribute
@@ -1904,35 +2476,35 @@ var CABProgressBarSection = import_zod22.z.lazy(
      * checkout reaches the extension without it, so the client writes it or the tier gift's 100% discount
      * (and any tier order discount) never applies. Absent on the v1 shipping bar (no gift tiers, no id).
      */
-    barId: import_zod22.z.string().optional(),
+    barId: import_zod33.z.string().optional(),
     /** Empty = shown everywhere; otherwise uppercase ISO country codes. */
-    countryCodes: import_zod22.z.array(import_zod22.z.string().transform((code) => code.trim().toUpperCase())).default(() => []),
+    countryCodes: import_zod33.z.array(import_zod33.z.string().transform((code) => code.trim().toUpperCase())).default(() => []),
     /**
      * Uppercase ISO codes where a higher-precedence geo bar applies, so this (default, non-geo) bar is
      * hidden there — replicates React `getbar`'s geo-match-over-default precedence. Empty = never excluded.
      */
-    excludeCountryCodes: import_zod22.z.array(import_zod22.z.string().transform((code) => code.trim().toUpperCase())).default(() => []),
+    excludeCountryCodes: import_zod33.z.array(import_zod33.z.string().transform((code) => code.trim().toUpperCase())).default(() => []),
     /**
      * Measure progress against the PRE-discount subtotal (onsite `exclude_discount_in_subtotal`, and
      * forced on for bars with a discount tier so its own reward can't un-reach the tier). The client
      * adds the cart's discount allocations back to the live subtotal.
      */
-    excludeDiscountInSubtotal: import_zod22.z.boolean().default(false),
+    excludeDiscountInSubtotal: import_zod33.z.boolean().default(false),
     /** Variant ids the client subtracts from the adjusted subtotal (React `bar.excluded_products`). */
-    excludedVariantIds: import_zod22.z.array(import_zod22.z.number().int().positive()).default(() => []),
+    excludedVariantIds: import_zod33.z.array(import_zod33.z.number().int().positive()).default(() => []),
     /**
      * When the cart holds a subscription item, treat the bar as reached regardless of subtotal (React
      * `free_shipping_on_subscription(s)`). `freeShippingOnAll` is already a zero-threshold tier instead.
      */
-    freeShippingOnSubscription: import_zod22.z.boolean().default(false),
+    freeShippingOnSubscription: import_zod33.z.boolean().default(false),
     /** Localized heading over the gift controls (onsite `gift_area_title`, default 'FREE GIFTS'). */
-    giftAreaTitle: import_zod22.z.record(import_zod22.z.string(), import_zod22.z.string()).default(() => ({ en: "FREE GIFTS" })),
+    giftAreaTitle: import_zod33.z.record(import_zod33.z.string(), import_zod33.z.string()).default(() => ({ en: "FREE GIFTS" })),
     /** Localized gift-control labels (add/remove/heading); a tier's gift `title` beats `yourGift`. */
-    giftLabels: import_zod22.z.object({
-      addGift: import_zod22.z.record(import_zod22.z.string(), import_zod22.z.string()).default(() => ({ ...GIFT_LABELS.addGift })),
-      remove: import_zod22.z.record(import_zod22.z.string(), import_zod22.z.string()).default(() => ({ ...GIFT_LABELS.remove })),
-      selectOptions: import_zod22.z.record(import_zod22.z.string(), import_zod22.z.string()).default(() => ({ ...GIFT_LABELS.selectOptions })),
-      yourGift: import_zod22.z.record(import_zod22.z.string(), import_zod22.z.string()).default(() => ({ ...GIFT_LABELS.yourGift }))
+    giftLabels: import_zod33.z.object({
+      addGift: import_zod33.z.record(import_zod33.z.string(), import_zod33.z.string()).default(() => ({ ...GIFT_LABELS.addGift })),
+      remove: import_zod33.z.record(import_zod33.z.string(), import_zod33.z.string()).default(() => ({ ...GIFT_LABELS.remove })),
+      selectOptions: import_zod33.z.record(import_zod33.z.string(), import_zod33.z.string()).default(() => ({ ...GIFT_LABELS.selectOptions })),
+      yourGift: import_zod33.z.record(import_zod33.z.string(), import_zod33.z.string()).default(() => ({ ...GIFT_LABELS.yourGift }))
     }).default(() => ({
       addGift: { ...GIFT_LABELS.addGift },
       remove: { ...GIFT_LABELS.remove },
@@ -1940,38 +2512,38 @@ var CABProgressBarSection = import_zod22.z.lazy(
       yourGift: { ...GIFT_LABELS.yourGift }
     })),
     /** The bar's a11y label; the merchant names it in the editor, else this default (React parity). */
-    name: import_zod22.z.string().default("Order progress"),
+    name: import_zod33.z.string().default("Order progress"),
     /**
      * Bar fill color. An explicit (widget-authored) value is used verbatim; when absent the server
      * fills it with the live shop theme's `buttonBackground` (React `useRebuyTheme` parity). Still
      * absent after that ⇒ the theme fetch failed and the client renders its platform-default bar —
      * optional, not defaulted, so "merchant chose no color" stays distinguishable from any real value.
      */
-    progressColor: import_zod22.z.string().optional(),
-    sectionType: import_zod22.z.literal(SectionType.progressBar).default(SectionType.progressBar),
+    progressColor: import_zod33.z.string().optional(),
+    sectionType: import_zod33.z.literal(SectionType.progressBar).default(SectionType.progressBar),
     /**
      * The bar's milestones in the merchant's CONFIGURED order — the renderer does NOT sort them (022
      * O-B2: sorting by resolved threshold reversed configured milestones on out-of-order or mixed-unit
      * count-vs-cents bars). Drives the fill (even slot per tier) and, for smart-cart product tiers, the
      * gift add/remove. The visual tier display lives in `sections` (composable), NOT here.
      */
-    tiers: import_zod22.z.union([import_zod22.z.array(CABProgressTier), import_zod22.z.strictObject({}).transform(() => [])]).default(() => [])
+    tiers: import_zod33.z.union([import_zod33.z.array(CABProgressTier), import_zod33.z.strictObject({}).transform(() => [])]).default(() => [])
   })
 );
 
 // src/schema/widgets/checkout-and-beyond/quantity.ts
-var import_uuid9 = require("uuid");
-var import_zod23 = require("zod");
-var CABQuantitySection = import_zod23.z.object({
+var import_uuid10 = require("uuid");
+var import_zod34 = require("zod");
+var CABQuantitySection = import_zod34.z.object({
   ...CABVariableFields,
-  errorMessages: import_zod23.z.record(
-    import_zod23.z.string(),
-    import_zod23.z.object({
+  errorMessages: import_zod34.z.record(
+    import_zod34.z.string(),
+    import_zod34.z.object({
       /** `{{step}}` is interpolated at render — the off-increment message React never gave a merchant key. */
-      increment: import_zod23.z.string().optional(),
-      max: import_zod23.z.string().optional(),
-      min: import_zod23.z.string().optional(),
-      neg: import_zod23.z.string().optional()
+      increment: import_zod34.z.string().optional(),
+      max: import_zod34.z.string().optional(),
+      min: import_zod34.z.string().optional(),
+      neg: import_zod34.z.string().optional()
     })
   ).default({
     en: {
@@ -1981,18 +2553,18 @@ var CABQuantitySection = import_zod23.z.object({
       neg: "Quantity cannot be negative"
     }
   }),
-  inputType: import_zod23.z.enum(quantityInputs).default(QuantityInput.select),
-  max: import_zod23.z.number().min(1).max(100).default(10),
-  min: import_zod23.z.number().min(1).default(1),
+  inputType: import_zod34.z.enum(quantityInputs).default(QuantityInput.select),
+  max: import_zod34.z.number().min(1).max(100).default(10),
+  min: import_zod34.z.number().min(1).default(1),
   /** The a11y label for the quantity control; the merchant names it in the editor, else this default. */
-  name: import_zod23.z.string().default("Quantity"),
-  sectionId: import_zod23.z.uuid().default(() => (0, import_uuid9.v7)()),
-  sectionType: import_zod23.z.literal(SectionType.quantity).default(SectionType.quantity)
+  name: import_zod34.z.string().default("Quantity"),
+  sectionId: import_zod34.z.uuid().default(() => (0, import_uuid10.v7)()),
+  sectionType: import_zod34.z.literal(SectionType.quantity).default(SectionType.quantity)
 });
 
 // src/schema/widgets/checkout-and-beyond/reviews.ts
-var import_uuid10 = require("uuid");
-var import_zod24 = require("zod");
+var import_uuid11 = require("uuid");
+var import_zod35 = require("zod");
 
 // src/schema/widgets/checkout-and-beyond/reviewLabels.ts
 var REVIEW_LABELS = {
@@ -2055,49 +2627,49 @@ var REVIEW_LABELS = {
 };
 
 // src/schema/widgets/checkout-and-beyond/reviews.ts
-var CABReviewsSection = import_zod24.z.object({
+var CABReviewsSection = import_zod35.z.object({
   ...CABVariableFields,
-  color: import_zod24.z.string().default("#fadb14"),
+  color: import_zod35.z.string().default("#fadb14"),
   /**
    * Localized review-count templates (`{{reviewCount}}`), one/other plural forms; the client picks the
    * form via `Intl.PluralRules`. Defaults here (schema-first) so every tree localizes without converter
    * or merchant work.
    */
-  countLabels: import_zod24.z.object({
-    one: import_zod24.z.record(import_zod24.z.string(), import_zod24.z.string()).default(() => ({ ...REVIEW_LABELS.one })),
-    other: import_zod24.z.record(import_zod24.z.string(), import_zod24.z.string()).default(() => ({ ...REVIEW_LABELS.other }))
+  countLabels: import_zod35.z.object({
+    one: import_zod35.z.record(import_zod35.z.string(), import_zod35.z.string()).default(() => ({ ...REVIEW_LABELS.one })),
+    other: import_zod35.z.record(import_zod35.z.string(), import_zod35.z.string()).default(() => ({ ...REVIEW_LABELS.other }))
   }).default(() => ({ one: { ...REVIEW_LABELS.one }, other: { ...REVIEW_LABELS.other } })),
-  name: import_zod24.z.string().optional(),
-  sectionId: import_zod24.z.uuid().default(() => (0, import_uuid10.v7)()),
-  sectionType: import_zod24.z.literal(SectionType.reviews).default(SectionType.reviews),
-  size: import_zod24.z.enum(reviewsSizes).default(ReviewsSize.default),
+  name: import_zod35.z.string().optional(),
+  sectionId: import_zod35.z.uuid().default(() => (0, import_uuid11.v7)()),
+  sectionType: import_zod35.z.literal(SectionType.reviews).default(SectionType.reviews),
+  size: import_zod35.z.enum(reviewsSizes).default(ReviewsSize.default),
   /**
    * Star outline color, interpolated into a style by the renderer, so it is hex-constrained like
    * `CABButtonSection.color`. The legacy source (`PostPurchaseSettings.styles.starStrokeColor`) is a free
    * string: its converter must validate and fall back to this default rather than let one odd value drop
    * the whole reviews section.
    */
-  strokeColor: import_zod24.z.string().regex(HEX_COLOR_REGEX).default("#fadb14"),
+  strokeColor: import_zod35.z.string().regex(HEX_COLOR_REGEX).default("#fadb14"),
   /** Star outline width in px; `0` draws no outline. The legacy `styles.strokeWidth` is a STRING ('1') — its converter coerces. */
-  strokeWidth: import_zod24.z.number().nonnegative().default(0)
+  strokeWidth: import_zod35.z.number().nonnegative().default(0)
 });
 
 // src/schema/widgets/checkout-and-beyond/separator.ts
-var import_uuid11 = require("uuid");
-var import_zod25 = require("zod");
-var CABSeparatorSection = import_zod25.z.object({
+var import_uuid12 = require("uuid");
+var import_zod36 = require("zod");
+var CABSeparatorSection = import_zod36.z.object({
   ...CABVariableFields,
-  sectionId: import_zod25.z.uuid().default(() => (0, import_uuid11.v7)()),
-  sectionType: import_zod25.z.literal(SectionType.separator).default(SectionType.separator)
+  sectionId: import_zod36.z.uuid().default(() => (0, import_uuid12.v7)()),
+  sectionType: import_zod36.z.literal(SectionType.separator).default(SectionType.separator)
 });
 
 // src/schema/widgets/checkout-and-beyond/variants.ts
-var import_compat3 = require("es-toolkit/compat");
-var import_uuid12 = require("uuid");
-var import_zod26 = require("zod");
-var CABVariantsSection = import_zod26.z.object({
+var import_compat5 = require("es-toolkit/compat");
+var import_uuid13 = require("uuid");
+var import_zod37 = require("zod");
+var CABVariantsSection = import_zod37.z.object({
   ...CABVariableFields,
-  hideOutOfStockVariants: import_zod26.z.boolean().default(false),
+  hideOutOfStockVariants: import_zod37.z.boolean().default(false),
   /**
    * The menu's own label per buyer locale (`selectLanguage`), for the whole-variant (`single`) and the
    * product-group menus; `multiple` labels each option's menu by its name. Optional and additive
@@ -2108,30 +2680,30 @@ var CABVariantsSection = import_zod26.z.object({
    * `selectLanguage` returning `''` — which a renderer's `??` fallback would show as an empty menu label.
    * A label left with no entries reads as absent.
    */
-  label: import_zod26.z.record(import_zod26.z.string(), import_zod26.z.string()).transform((label2) => {
-    const filled = (0, import_compat3.pickBy)(label2, (value) => value.trim() !== "");
-    return (0, import_compat3.isEmpty)(filled) ? void 0 : filled;
+  label: import_zod37.z.record(import_zod37.z.string(), import_zod37.z.string()).transform((label2) => {
+    const filled = (0, import_compat5.pickBy)(label2, (value) => value.trim() !== "");
+    return (0, import_compat5.isEmpty)(filled) ? void 0 : filled;
   }).optional().catch(void 0),
-  name: import_zod26.z.string().optional(),
-  sectionId: import_zod26.z.uuid().default(() => (0, import_uuid12.v7)()),
-  sectionType: import_zod26.z.literal(SectionType.variants).default(SectionType.variants),
-  selector: import_zod26.z.enum((0, import_compat3.slice)(variantSelectors, 0, 3)).default(VariantSelector.menu),
+  name: import_zod37.z.string().optional(),
+  sectionId: import_zod37.z.uuid().default(() => (0, import_uuid13.v7)()),
+  sectionType: import_zod37.z.literal(SectionType.variants).default(SectionType.variants),
+  selector: import_zod37.z.enum((0, import_compat5.slice)(variantSelectors, 0, 3)).default(VariantSelector.menu),
   /** `productGroup` is additive (REB-24817): a renderer without group support must render nothing for it. */
-  variantMode: import_zod26.z.enum(variantsModes).default(VariantsMode.multiple)
+  variantMode: import_zod37.z.enum(variantsModes).default(VariantsMode.multiple)
 });
 
 // src/schema/widgets/checkout-and-beyond/shared.ts
-var CABBorder = import_zod27.z.object({
-  radius: import_zod27.z.enum(borderRadii).default(BorderRadius.base),
-  style: import_zod27.z.enum(borderStyles).default(BorderStyle.none),
-  width: import_zod27.z.enum(borderWidths).default(BorderWidth.base)
+var CABBorder = import_zod38.z.object({
+  radius: import_zod38.z.enum(borderRadii).default(BorderRadius.base),
+  style: import_zod38.z.enum(borderStyles).default(BorderStyle.none),
+  width: import_zod38.z.enum(borderWidths).default(BorderWidth.base)
 }).default({
   radius: BorderRadius.base,
   style: BorderStyle.none,
   width: BorderWidth.base
 });
-var CABSection = import_zod27.z.lazy(
-  () => import_zod27.z.discriminatedUnion("sectionType", [
+var CABSection = import_zod38.z.lazy(
+  () => import_zod38.z.discriminatedUnion("sectionType", [
     CABBannerSection,
     CABButtonSection,
     CABCarouselSection,
@@ -2154,17 +2726,17 @@ var CABSection = import_zod27.z.lazy(
 );
 
 // src/schema/widgets/checkout-and-beyond/image.ts
-var CABImageSectionFields = import_zod28.z.object({
+var CABImageSectionFields = import_zod39.z.object({
   ...CABVariableFields,
-  altText: import_zod28.z.string().refine(checkForHTML, NO_HTML).default(""),
+  altText: import_zod39.z.string().refine(checkForHTML, NO_HTML).default(""),
   /**
    * Image width÷height (e.g. `46` for the progress-bar fill); `null` renders at natural size. Any POSITIVE
    * ratio — never limited to 1, but never `0`/negative either: a renderer dividing by it would get `Infinity`,
    * and CSS `aspect-ratio` drops a negative value and silently reverts to natural size.
    */
-  aspectRatio: import_zod28.z.number().positive().nullable().default(null),
-  border: import_zod28.z.lazy(() => CABBorder),
-  buttonField: import_zod28.z.enum(buttonFields).optional(),
+  aspectRatio: import_zod39.z.number().positive().nullable().default(null),
+  border: import_zod39.z.lazy(() => CABBorder),
+  buttonField: import_zod39.z.enum(buttonFields).optional(),
   /**
    * `icon` renders `source` as a single `s-icon` by name (the uber-image path covers icons too), reading
    * `iconSize`/`iconTone`. The other values are a harmless informational holdover from the previous
@@ -2183,30 +2755,30 @@ var CABImageSectionFields = import_zod28.z.object({
    * behavior degraded gracefully and told us about it. The client-assembled half of the invariant was never
    * the risky half.
    */
-  category: import_zod28.z.enum(["gallery", "icon", "icons", "payment-methods", "secure-checkout"]).nullable().default(null),
+  category: import_zod39.z.enum(["gallery", "icon", "icons", "payment-methods", "secure-checkout"]).nullable().default(null),
   /** `icon`-mode only: the `s-icon` `size`; `null` ⇒ the component default (`base`). Ignored by image treatments. */
-  iconSize: import_zod28.z.enum(iconSizes).nullable().default(null),
+  iconSize: import_zod39.z.enum(iconSizes).nullable().default(null),
   /** `icon`-mode only: the `s-icon` `tone`; `null` ⇒ the component default (`auto`). Ignored by image treatments. */
-  iconTone: import_zod28.z.enum(iconTones).nullable().default(null),
-  name: import_zod28.z.string().optional(),
-  naturalHeight: import_zod28.z.number().default(0),
-  naturalWidth: import_zod28.z.number().default(0),
+  iconTone: import_zod39.z.enum(iconTones).nullable().default(null),
+  name: import_zod39.z.string().optional(),
+  naturalHeight: import_zod39.z.number().default(0),
+  naturalWidth: import_zod39.z.number().default(0),
   /**
    * `contain` (the component default): dimensionless images render in s-image's 1/1 default frame, and
    * `cover` would crop non-square art (payment badges lost their edges — 15993); `contain` letterboxes.
    */
-  objectFit: import_zod28.z.enum(objectFits).default(ObjectFit.contain),
-  sectionId: import_zod28.z.uuid().default(() => (0, import_uuid13.v7)()),
-  sectionType: import_zod28.z.literal(SectionType.image).default(SectionType.image),
+  objectFit: import_zod39.z.enum(objectFits).default(ObjectFit.contain),
+  sectionId: import_zod39.z.uuid().default(() => (0, import_uuid14.v7)()),
+  sectionType: import_zod39.z.literal(SectionType.image).default(SectionType.image),
   /**
    * An image URL or dynamic token, an empty default, or — when `category: 'icon'` — an icon NAME. Icon mode
    * takes a name or `''` only, NOT a token: no renderer resolves a token to an icon today, so accepting one
    * would promise a capability that doesn't exist. Widen the refine's carve-out to `DYNAMIC_TOKEN_REGEX` when a
    * server-chosen tier icon actually needs it.
    */
-  source: import_zod28.z.union([import_zod28.z.url(), import_zod28.z.literal(""), import_zod28.z.string().regex(DYNAMIC_TOKEN_REGEX), import_zod28.z.enum(iconNames)]).default(""),
+  source: import_zod39.z.union([import_zod39.z.url(), import_zod39.z.literal(""), import_zod39.z.string().regex(DYNAMIC_TOKEN_REGEX), import_zod39.z.enum(iconNames)]).default(""),
   thumbnails: CABImageThumbnails.optional(),
-  width: import_zod28.z.number().default(100)
+  width: import_zod39.z.number().default(100)
 });
 var iconNameSet = new Set(iconNames);
 var isIconName = (source2) => iconNameSet.has(source2);
@@ -2357,7 +2929,7 @@ var convertContentBlockTextToV2 = (language3, text2 = literalText, textAlign = "
 };
 
 // src/schema/widgets/checkout-and-beyond/root.ts
-var import_zod29 = require("zod");
+var import_zod40 = require("zod");
 
 // src/schema/widgets/checkout-and-beyond/uiLabels.ts
 var UI_LABELS = {
@@ -2377,8 +2949,8 @@ var UI_LABELS = {
 };
 
 // src/schema/widgets/checkout-and-beyond/root.ts
-var localized = (fallback) => import_zod29.z.record(import_zod29.z.string(), import_zod29.z.string()).default(() => ({ ...fallback })).transform((labels) => Object.keys(labels).length > 0 ? labels : { ...fallback });
-var CABUILabels = import_zod29.z.object({
+var localized = (fallback) => import_zod40.z.record(import_zod40.z.string(), import_zod40.z.string()).default(() => ({ ...fallback })).transform((labels) => Object.keys(labels).length > 0 ? labels : { ...fallback });
+var CABUILabels = import_zod40.z.object({
   currentPage: localized(UI_LABELS.currentPage),
   guest: localized(UI_LABELS.guest),
   loadingOptions: localized(UI_LABELS.loadingOptions),
@@ -2403,37 +2975,37 @@ var CABUILabels = import_zod29.z.object({
   subscriptionOptions: { ...UI_LABELS.subscriptionOptions },
   updating: { ...UI_LABELS.updating }
 }));
-var TargetArea = import_zod29.z.object({
-  fill: import_zod29.z.boolean().optional(),
-  flip: import_zod29.z.enum(["both", "horizontal", "vertical"]).optional(),
-  icon: import_zod29.z.string(),
-  label: import_zod29.z.string(),
-  width: import_zod29.z.string()
+var TargetArea = import_zod40.z.object({
+  fill: import_zod40.z.boolean().optional(),
+  flip: import_zod40.z.enum(["both", "horizontal", "vertical"]).optional(),
+  icon: import_zod40.z.string(),
+  label: import_zod40.z.string(),
+  width: import_zod40.z.string()
 }).default(targetAreas[EditorMode.checkoutExtension][1]);
-var CABTracking = import_zod29.z.object({
-  enableAttribution: import_zod29.z.boolean().nullish().transform((value) => value ?? true),
-  enableSource: import_zod29.z.boolean().nullish().transform((value) => value ?? true),
-  enableWidget: import_zod29.z.boolean().nullish().transform((value) => value ?? true)
+var CABTracking = import_zod40.z.object({
+  enableAttribution: import_zod40.z.boolean().nullish().transform((value) => value ?? true),
+  enableSource: import_zod40.z.boolean().nullish().transform((value) => value ?? true),
+  enableWidget: import_zod40.z.boolean().nullish().transform((value) => value ?? true)
 }).nullish().transform((value) => value ?? { enableAttribution: true, enableSource: true, enableWidget: true });
-var CABExperiment = import_zod29.z.object({
-  elementId: import_zod29.z.number(),
-  experimentId: import_zod29.z.number(),
-  experimentType: import_zod29.z.string(),
-  selectedId: import_zod29.z.number()
+var CABExperiment = import_zod40.z.object({
+  elementId: import_zod40.z.number(),
+  experimentId: import_zod40.z.number(),
+  experimentType: import_zod40.z.string(),
+  selectedId: import_zod40.z.number()
 });
 var CABRootSection = CABLayoutSection.extend({
-  editorMode: import_zod29.z.enum(editorModes).default(EditorMode.checkoutExtension),
+  editorMode: import_zod40.z.enum(editorModes).default(EditorMode.checkoutExtension),
   experiment: CABExperiment.optional(),
   // Same rule as CABTracking above: the v1 converters pass raw legacy `previewMode` through, so a
   // `null` must fall back rather than throw the widget; malformed values still throw.
-  previewMode: import_zod29.z.boolean().nullish().transform((value) => value ?? false),
-  storeId: import_zod29.z.number().nullable().default(null),
+  previewMode: import_zod40.z.boolean().nullish().transform((value) => value ?? false),
+  storeId: import_zod40.z.number().nullable().default(null),
   targetArea: TargetArea.nullable(),
   tracking: CABTracking,
-  type: import_zod29.z.enum(widgetTypes).default(WidgetType.ui_extension_content_block),
+  type: import_zod40.z.enum(widgetTypes).default(WidgetType.ui_extension_content_block),
   uiLabels: CABUILabels,
-  version: import_zod29.z.literal(2).default(2),
-  widgetId: import_zod29.z.number().nullable().default(null)
+  version: import_zod40.z.literal(2).default(2),
+  widgetId: import_zod40.z.number().nullable().default(null)
 });
 
 // src/transforms/v1Location.ts
@@ -3926,172 +4498,10 @@ var convertOfferToV2 = ({ id, name, settings }) => {
 var parseShielded = (schema, raw, transform = (input) => input) => schema.parse(transform(convertNumericObjects(deepCamelCase(raw))));
 
 // src/transforms/postPurchase/convertMessagePreview.ts
-var import_zod40 = require("zod");
+var import_zod47 = require("zod");
 
 // src/transforms/postPurchase/convertCalloutBlock.ts
-var import_zod32 = require("zod");
-
-// src/schema/widgets/post-purchase-offer/postPurchaseBlocks.ts
-var import_compat4 = require("es-toolkit/compat");
-var import_uuid14 = require("uuid");
-var import_zod31 = require("zod");
-
-// src/schema/widgets/post-purchase-offer/constants.ts
-var import_zod30 = require("zod");
-var blockTypes = [
-  "callout_banner",
-  "image",
-  "image_content",
-  "pay_button",
-  "product_information",
-  "separator",
-  "text",
-  "timer"
-];
-var blockType = import_zod30.z.enum(blockTypes);
-var BlockType = blockType.enum;
-
-// src/schema/widgets/post-purchase-offer/postPurchaseBlocks.ts
-var TextAlignment2 = import_zod31.z.union([import_zod31.z.enum(["leading", "center", "trailing"]), import_zod31.z.unknown().transform(() => "leading")]);
-var TextSize = import_zod31.z.union([
-  import_zod31.z.enum(["xsmall", "small", "base", "default", "medium", "large", "xlarge"]),
-  import_zod31.z.unknown().transform(() => "medium")
-]);
-var CalloutBannerBlock = import_zod31.z.object({
-  id: import_zod31.z.string().optional().default(() => (0, import_uuid14.v4)()),
-  name: import_zod31.z.string().optional(),
-  settings: import_zod31.z.object({
-    superTitle: import_zod31.z.union([import_zod31.z.string(), TiptapDocument]).default(() => "Limited-time Offer"),
-    title: import_zod31.z.union([import_zod31.z.string(), TiptapDocument]).default(() => "Add this customer favorite to your order")
-  }),
-  styles: import_zod31.z.object({
-    superTitleEmphasized: import_zod31.z.boolean().default(false),
-    superTitleSize: TextSize.default("large"),
-    textAlignment: TextAlignment2.default("center"),
-    titleEmphasized: import_zod31.z.boolean().default(true),
-    titleSize: TextSize.default("large")
-  }),
-  type: import_zod31.z.literal(BlockType.callout_banner).default(BlockType.callout_banner)
-});
-var ImageBlock = import_zod31.z.object({
-  id: import_zod31.z.string().optional().default(() => (0, import_uuid14.v4)()),
-  name: import_zod31.z.string().optional(),
-  settings: import_zod31.z.union([
-    import_zod31.z.object({
-      /** This isn't used in the post-purchase offer widget */
-      alt: import_zod31.z.string().optional().default(""),
-      image: import_zod31.z.union([import_zod31.z.literal(""), import_zod31.z.url()]).default(""),
-      imageSize: import_zod31.z.number().default(20),
-      imageType: import_zod31.z.enum(["URL", "UPLOAD"]).default("URL")
-    }),
-    import_zod31.z.array(import_zod31.z.never()).transform(() => ({}))
-  ]),
-  type: import_zod31.z.literal(BlockType.image).default(BlockType.image)
-});
-var ImageContentBlock = import_zod31.z.object({
-  id: import_zod31.z.string().optional().default(() => (0, import_uuid14.v4)()),
-  name: import_zod31.z.string().optional(),
-  settings: import_zod31.z.object({
-    alt: import_zod31.z.string().optional().default(""),
-    description: import_zod31.z.union([import_zod31.z.string(), TiptapDocument, import_zod31.z.null()]).default(
-      "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum."
-    ),
-    descriptionSize: TextSize.default("medium"),
-    horizontalAlignment: TextAlignment2.default("leading"),
-    image: import_zod31.z.union([import_zod31.z.literal(""), import_zod31.z.url()]).default(""),
-    imagePlacement: import_zod31.z.enum(["bottom", "left", "right", "top"]).optional().default("left"),
-    imageSize: import_zod31.z.number().default(20),
-    superTitle: import_zod31.z.union([import_zod31.z.string(), TiptapDocument]).default("Lorem Ipsum!"),
-    superTitleSize: TextSize.default("medium"),
-    /** This isn't configurable in the admin-nextjs editor */
-    swapContent: import_zod31.z.boolean().optional().default(false),
-    title: import_zod31.z.union([import_zod31.z.string(), TiptapDocument]).nullable().default("Lorem ipsum dolor sit amet"),
-    titleSize: TextSize.default("medium")
-  }),
-  type: import_zod31.z.literal(BlockType.image_content).default(BlockType.image_content)
-});
-var PayButtonBlock = import_zod31.z.object({
-  id: import_zod31.z.string().optional().default(() => (0, import_uuid14.v4)()),
-  name: import_zod31.z.string().optional(),
-  settings: import_zod31.z.union([
-    import_zod31.z.object({
-      label: import_zod31.z.string().default("Pay Now")
-    }),
-    import_zod31.z.array(import_zod31.z.never()).transform(() => ({
-      label: "Pay Now"
-    }))
-  ]),
-  styles: import_zod31.z.union([
-    import_zod31.z.object({
-      buttonWidth: import_zod31.z.number().min(10).max(100).default(50)
-    }),
-    import_zod31.z.array(import_zod31.z.never()).transform(() => ({
-      buttonWidth: 50
-    }))
-  ]),
-  type: import_zod31.z.literal(BlockType.pay_button).default(BlockType.pay_button)
-});
-var ProductInformationBlock = import_zod31.z.object({
-  /** This isn't configurable in the admin-nextjs editor */
-  hideProductImage: import_zod31.z.boolean().optional().default(false),
-  id: import_zod31.z.string().optional().default(() => (0, import_uuid14.v4)()),
-  name: import_zod31.z.string().optional(),
-  type: import_zod31.z.literal(BlockType.product_information).default(BlockType.product_information)
-});
-var SeparatorBlock = import_zod31.z.object({
-  id: import_zod31.z.string().optional().default(() => (0, import_uuid14.v4)()),
-  name: import_zod31.z.string().optional(),
-  type: import_zod31.z.literal(BlockType.separator).default(BlockType.separator)
-});
-var TextBlock = import_zod31.z.object({
-  id: import_zod31.z.string().optional().default(() => (0, import_uuid14.v4)()),
-  name: import_zod31.z.string().optional(),
-  settings: import_zod31.z.object({
-    description: import_zod31.z.union([import_zod31.z.string(), TiptapDocument]).optional().default(
-      "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum."
-    ),
-    /** This isn't used in the post-purchase offer widget */
-    descriptionSize: TextSize.default("medium"),
-    horizontalAlignment: TextAlignment2.default("leading"),
-    superTitle: import_zod31.z.union([import_zod31.z.string(), TiptapDocument]).default("Super Title"),
-    /** This isn't used in the post-purchase offer widget */
-    superTitleSize: TextSize.default("medium"),
-    title: import_zod31.z.union([import_zod31.z.string(), TiptapDocument]).nullable().default("Lorem ipsum dolor sit amet."),
-    /** This isn't used in the post-purchase offer widget */
-    titleSize: TextSize.default("medium")
-  }),
-  type: import_zod31.z.literal(BlockType.text).default(BlockType.text)
-});
-var TimerBlock = import_zod31.z.object({
-  id: import_zod31.z.string().optional().default(() => (0, import_uuid14.v4)()),
-  name: import_zod31.z.string().optional(),
-  settings: import_zod31.z.object({
-    durationMinutes: import_zod31.z.number().min(0).default(10),
-    durationSeconds: import_zod31.z.union([import_zod31.z.number().min(0), import_zod31.z.unknown().transform(() => 0)]).default(0),
-    endOffer: import_zod31.z.boolean().default(true),
-    title: import_zod31.z.union([import_zod31.z.string(), TiptapDocument]).default("Hurry \u2014 your special offer ends in:")
-  }),
-  styles: import_zod31.z.object({
-    textAlignment: TextAlignment2.default("center"),
-    timerBackgroundColor: import_zod31.z.enum(["info", "warning", "success", "critical"]).default("warning"),
-    timerEmphasized: import_zod31.z.union([import_zod31.z.boolean(), import_zod31.z.unknown().transform(() => true)]).default(true),
-    timerSize: TextSize.default("medium"),
-    timerWidth: import_zod31.z.number().min(10).max(100).optional().default(100),
-    titleEmphasized: import_zod31.z.union([import_zod31.z.boolean(), import_zod31.z.unknown().transform(() => true)]).default(false),
-    titleSize: TextSize.default("medium")
-  }),
-  type: import_zod31.z.literal(BlockType.timer).default(BlockType.timer)
-});
-var PostPurchaseBlock = import_zod31.z.discriminatedUnion("type", [
-  CalloutBannerBlock,
-  ImageBlock,
-  ImageContentBlock,
-  PayButtonBlock,
-  ProductInformationBlock,
-  SeparatorBlock,
-  TextBlock,
-  TimerBlock
-]);
+var import_zod41 = require("zod");
 
 // src/transforms/postPurchase/styledTextRun.ts
 var sizes = {
@@ -4115,7 +4525,7 @@ var styledTextRun = (text2, emphasized, size) => ({
 // src/transforms/postPurchase/convertCalloutBlock.ts
 var fields = ["superTitle", "title"];
 var Shell = CalloutBannerBlock.pick({ styles: true }).extend({
-  settings: import_zod32.z.object({ superTitle: import_zod32.z.unknown().optional(), title: import_zod32.z.unknown().optional() })
+  settings: import_zod41.z.object({ superTitle: import_zod41.z.unknown().optional(), title: import_zod41.z.unknown().optional() })
 });
 var convertCalloutBlock = (raw, report) => {
   const omit = (detail) => {
@@ -4150,7 +4560,7 @@ var convertCalloutBlock = (raw, report) => {
 };
 
 // src/transforms/postPurchase/convertImageFrame.ts
-var import_zod33 = require("zod");
+var import_zod42 = require("zod");
 
 // src/transforms/postPurchase/sizeImageSource.ts
 var sizeImageSource = (source2, size) => {
@@ -4162,7 +4572,7 @@ var sizeImageSource = (source2, size) => {
 };
 
 // src/transforms/postPurchase/convertImageFrame.ts
-var Source = import_zod33.z.url().default("https://cdn.shopify.com/s/files/1/0605/0555/5177/files/placeholder.jpg?v=1657762972");
+var Source = import_zod42.z.url().default("https://cdn.shopify.com/s/files/1/0605/0555/5177/files/placeholder.jpg?v=1657762972");
 var DEFAULT_IMAGE_SIZE = 20;
 var convertImageFrame = (raw) => {
   const parsed = ImageBlock.shape.settings.options[0].safeParse(raw);
@@ -4208,7 +4618,7 @@ var convertImageBlock = (raw, report) => {
 };
 
 // src/transforms/postPurchase/convertImageContentBlock.ts
-var import_zod35 = require("zod");
+var import_zod44 = require("zod");
 
 // src/transforms/postPurchase/convertImageContentText.ts
 var fields2 = ["superTitle", "title", "description"];
@@ -4233,286 +4643,98 @@ var convertImageContentText = (settings, report) => {
     } : text2;
     const section = CABTextSection.safeParse({ content: { en: content } });
     return section.success ? [section.data] : omit();
-  });
-  return CABLayoutSection.parse({ alignment: { horizontal }, sections });
-};
-
-// src/transforms/postPurchase/imageContentSettings.ts
-var import_zod34 = require("zod");
-var ImageContentSettings = ImageContentBlock.shape.settings.pick({
-  descriptionSize: true,
-  horizontalAlignment: true,
-  superTitleSize: true,
-  swapContent: true,
-  titleSize: true
-}).extend({
-  alt: import_zod34.z.unknown().optional(),
-  description: import_zod34.z.unknown().optional(),
-  image: import_zod34.z.unknown().optional(),
-  imagePlacement: ImageContentBlock.shape.settings.shape.imagePlacement.unwrap().nullable(),
-  imageSize: ImageContentBlock.shape.settings.shape.imageSize.pipe(import_zod34.z.number().positive()),
-  superTitle: import_zod34.z.unknown().optional(),
-  title: import_zod34.z.unknown().optional()
-});
-
-// src/transforms/postPurchase/convertImageContentBlock.ts
-var Shell2 = import_zod35.z.object({ settings: ImageContentSettings, type: import_zod35.z.literal("image_content") });
-var PROPORTIONAL_BREAK_AT = 500;
-var convertImageContentBlock = (raw, report) => {
-  const shell = Shell2.safeParse(raw);
-  if (!shell.success) {
-    report?.({ detail: "Unreadable post-purchase image-content block", kind: "section" });
-    return [];
-  }
-  const settings = shell.data.settings;
-  const alt = typeof settings.alt === "string" ? settings.alt : void 0;
-  if (settings.alt !== void 0 && alt === void 0) {
-    report?.({ detail: "Unreadable post-purchase image-content alt text", kind: "section" });
-  }
-  const image = convertImageFrame({ alt, image: settings.image, imageSize: settings.imageSize });
-  if (!image) report?.({ detail: "Unreadable post-purchase image-content image", kind: "section" });
-  const text2 = convertImageContentText(settings, report);
-  const textFrame = CABLayoutSection.parse({ direction: "grid", grid: { columns: ["100%"] }, sections: [text2] });
-  const placement = settings.imagePlacement ?? (settings.swapContent ? "right" : "left");
-  const imageFirst = placement === "left" || placement === "top";
-  const sections = imageFirst ? [image, textFrame] : [textFrame, image];
-  const ordered = sections.filter((section) => section !== null);
-  const inner = placement === "left" || placement === "right" ? CABLayoutSection.parse({
-    sections: ordered,
-    spacing: "loose",
-    wrapping: {
-      breakAt: settings.imageSize <= 1 ? PROPORTIONAL_BREAK_AT : settings.imageSize,
-      maxPerLine: 2
-    }
-  }) : CABLayoutSection.parse({
-    direction: "grid",
-    grid: { columns: ["100%"] },
-    sections: [CABLayoutSection.parse({ sections: ordered })],
-    width: 95
-  });
-  return [CABLayoutSection.parse({ frame: "offer-content", sections: [inner], spacing: "none" })];
-};
-
-// src/transforms/postPurchase/productCardPay.ts
-var import_es_toolkit6 = require("es-toolkit");
-var PAY_NOW = { en: "Pay Now" };
-var DECLINE_THIS_OFFER = { en: "Decline this offer" };
-var NOT_AVAILABLE_DEFAULTS = ["Not available"];
-var soldOutSlot = ({ language: language3 }) => labelSlot("soldOut", OFFER_LABELS.soldOut, language3.global.notAvailable, [], NOT_AVAILABLE_DEFAULTS);
-var productCardPay = (settings) => {
-  const payNow = labelSlot("payNow", PAY_NOW, settings.language.global.payNow);
-  const priced = settings.language.displayCtaPrice ? { ...payNow, content: (0, import_es_toolkit6.mapValues)(payNow.content, (label2) => `${label2} \xB7 {{total}}`) } : payNow;
-  return [addToOrderButton("primary", [priced, soldOutSlot(settings)])];
-};
-var productCardDecline = ({ language: language3 }) => [
-  {
-    action: "declineOffer",
-    buttonStyle: "secondary",
-    sections: [labelSlot("declineOffer", DECLINE_THIS_OFFER, language3.global.declineThisOffer)],
-    sectionType: "button"
-  }
-];
-
-// src/transforms/postPurchase/productCardSettings.ts
-var import_es_toolkit7 = require("es-toolkit");
-var import_zod38 = require("zod");
-
-// src/schema/widgets/post-purchase-offer/postPurchaseSettings.ts
-var import_zod37 = require("zod");
-
-// src/schema/widgets/post-purchase-offer/common.ts
-var import_compat5 = require("es-toolkit/compat");
-var import_zod36 = require("zod");
-var strictNumber = import_zod36.z.union([
-  import_zod36.z.number(),
-  import_zod36.z.string().transform((value) => (0, import_compat5.toNumber)((0, import_compat5.replace)((0, import_compat5.toString)(value), /[^0-9.]/g, "")) || 0),
-  import_zod36.z.unknown().transform(() => 0)
-]);
-
-// src/schema/widgets/post-purchase-offer/postPurchaseSettings.ts
-var PostPurchaseSettings = import_zod37.z.object({
-  advance: import_zod37.z.object({ removePartialOrder: import_zod37.z.boolean().default(true) }).optional().default(() => ({ removePartialOrder: true })),
-  blocks: import_zod37.z.union([import_zod37.z.array(PostPurchaseBlock), import_zod37.z.unknown().transform(() => [])]).default(() => [
-    PostPurchaseBlock.parse({ settings: {}, styles: {}, type: BlockType.timer }),
-    PostPurchaseBlock.parse({ settings: {}, styles: {}, type: BlockType.callout_banner }),
-    PostPurchaseBlock.parse({ type: BlockType.product_information })
-  ]),
-  columnLayout: import_zod37.z.boolean().optional(),
-  discount: import_zod37.z.object({
-    amount: strictNumber.default(30),
-    shouldShowSavingText: import_zod37.z.boolean().optional().default(true),
-    type: import_zod37.z.enum(["none", "fixed_amount", "percentage"]).default("none")
-  }),
-  discountedFrom: import_zod37.z.enum(["price", "compare_at_price"]).optional().default("price"),
-  endpoint: import_zod37.z.string().optional(),
-  integrations: import_zod37.z.object({
-    judgeme: import_zod37.z.boolean().default(false),
-    junip: import_zod37.z.boolean().optional().default(false),
-    klaviyo: import_zod37.z.boolean().default(false),
-    loox: import_zod37.z.boolean().default(false),
-    okendo: import_zod37.z.boolean().default(false),
-    opinew: import_zod37.z.boolean().optional().default(false),
-    reviewsio: import_zod37.z.boolean().optional().default(false),
-    stamped: import_zod37.z.boolean().default(false),
-    yotpo: import_zod37.z.boolean().default(false)
-  }),
-  key: import_zod37.z.string().optional(),
-  language: import_zod37.z.object({
-    description: import_zod37.z.union([import_zod37.z.string(), import_zod37.z.unknown().transform(() => "")]).default(""),
-    descriptionEnabled: import_zod37.z.boolean().optional().default(false),
-    descriptionRte: import_zod37.z.object({
-      content: import_zod37.z.array(import_zod37.z.unknown()),
-      type: import_zod37.z.string()
-    }).optional(),
-    descriptionSpacing: import_zod37.z.enum(["none", "xtight", "tight", "default", "loose", "xloose"]).optional(),
-    displayCtaPrice: import_zod37.z.boolean().default(true),
-    global: import_zod37.z.object({
-      declineAll: import_zod37.z.string().optional().default("Decline All"),
-      declineThisOffer: import_zod37.z.string().default("Decline this offer"),
-      free: import_zod37.z.string().optional().default("Free"),
-      notAvailable: import_zod37.z.string().optional().default("Not available"),
-      payNow: import_zod37.z.string().default("Pay Now"),
-      payNowUpgradeToSubscription: import_zod37.z.string().optional().default("Upgrade to Subscription"),
-      quantity: import_zod37.z.string().default("Quantity"),
-      /** This isn't configurable in the admin-nextjs editor */
-      recurringShipping: import_zod37.z.string().optional().default("Recurring shipping"),
-      recurringSubtotal: import_zod37.z.string().default("Recurring subtotal"),
-      reviewsPlural: import_zod37.z.string().optional().default("Reviews"),
-      reviewsSingular: import_zod37.z.string().optional().default("Review"),
-      save: import_zod37.z.union([import_zod37.z.string(), import_zod37.z.unknown().transform(() => "Save")]).optional().default("Save"),
-      shipping: import_zod37.z.string().default("Shipping"),
-      subscriptionOption: import_zod37.z.string().optional().default("Subscribe and Save"),
-      subtotal: import_zod37.z.string().default("Subtotal"),
-      taxes: import_zod37.z.string().default("Taxes"),
-      total: import_zod37.z.string().default("Total")
-    }).optional().default(() => ({
-      declineAll: "Decline All",
-      declineThisOffer: "Decline this offer",
-      free: "Free",
-      notAvailable: "Not available",
-      payNow: "Pay Now",
-      payNowUpgradeToSubscription: "Upgrade to Subscription",
-      quantity: "Quantity",
-      /** This isn't configurable in the admin-nextjs editor */
-      recurringShipping: "Recurring shipping",
-      recurringSubtotal: "Recurring subtotal",
-      reviewsPlural: "Reviews",
-      reviewsSingular: "Review",
-      save: "Save",
-      shipping: "Shipping",
-      subscriptionOption: "Subscribe and Save",
-      subtotal: "Subtotal",
-      taxes: "Taxes",
-      total: "Total"
-    })),
-    globalTranslation: import_zod37.z.string().optional().default("english")
-  }),
-  metafields: import_zod37.z.boolean().default(false),
-  /** This isn't configurable in the admin-nextjs editor */
-  offer: import_zod37.z.object({
-    count: import_zod37.z.number().default(1)
-  }),
-  offersLayout: import_zod37.z.object({
-    itemsPerPage: import_zod37.z.number().optional(),
-    type: import_zod37.z.enum(["list", "grid", "carousel"]).default("list")
-  }).optional().default({
-    type: "list"
-  }),
-  /** This isn't configurable in the admin-nextjs editor */
-  previewMode: import_zod37.z.boolean().default(false),
-  productLimit: import_zod37.z.number().optional().default(1),
-  productOptions: import_zod37.z.object({
-    /** This isn't configurable in the admin-nextjs editor */
-    hideOutOfStockVariants: import_zod37.z.boolean().optional().default(false),
-    matchVariant: import_zod37.z.boolean().optional().default(true),
-    showDeclineAll: import_zod37.z.enum(["above", "below", "both", "none"]).optional(),
-    showShipping: import_zod37.z.boolean().optional().default(true),
-    showSubtotal: import_zod37.z.boolean().optional().default(true),
-    showTaxes: import_zod37.z.boolean().optional().default(true),
-    showTotal: import_zod37.z.boolean().optional().default(true),
-    showVariantSelectors: import_zod37.z.boolean().optional().default(true),
-    variantSelectorDisplayMode: import_zod37.z.enum(["separate", "single"]).optional().default("separate")
-  }),
-  productType: import_zod37.z.union([import_zod37.z.enum(["one-time", "subscription", "both"]), import_zod37.z.literal("").transform(() => "one-time")]).default("one-time"),
-  productTypeSelector: import_zod37.z.enum(["dropdown", "radio"]).optional().default("radio"),
-  quantityInputs: import_zod37.z.object({
-    defaultQuantity: import_zod37.z.union([import_zod37.z.number(), import_zod37.z.null().transform(() => 1)]).default(1),
-    enabled: import_zod37.z.boolean().default(true),
-    maxValue: import_zod37.z.union([import_zod37.z.number(), import_zod37.z.null().transform(() => 15)]).default(15),
-    minValue: import_zod37.z.union([import_zod37.z.number().min(0), import_zod37.z.unknown().transform(() => 0)]).default(1)
-  }),
-  shipping: import_zod37.z.object({
-    amount: strictNumber.default(10),
-    /** This isn't configurable in the admin-nextjs editor */
-    enabled: import_zod37.z.boolean().default(true),
-    title: import_zod37.z.string().optional().default("Shipping Fees"),
-    type: import_zod37.z.enum(["free", "fixed_amount"]).default("free")
-  }),
-  styles: import_zod37.z.object({
-    starColor: import_zod37.z.string().optional().default("#fadb14"),
-    starSize: import_zod37.z.union([import_zod37.z.enum(["small", "medium", "large"]), import_zod37.z.unknown().transform(() => "large")]).optional().default("large"),
-    starStrokeColor: import_zod37.z.string().optional().default("#fadb14"),
-    strokeWidth: import_zod37.z.string().optional().default("1")
-  }).optional(),
-  subImages: import_zod37.z.number().nullish().default(8),
-  subscription: import_zod37.z.object({
-    discount: import_zod37.z.object({
-      amount: strictNumber.default(30),
-      shouldShowSavingText: import_zod37.z.boolean().optional().default(true),
-      type: import_zod37.z.enum(["none", "fixed_amount", "percentage"]).default("none")
-    }),
-    shipping: import_zod37.z.object({
-      amount: strictNumber.default(1),
-      /** This isn't configurable in the admin-nextjs editor */
-      enabled: import_zod37.z.boolean().default(true),
-      /** This isn't configurable in the admin-nextjs editor */
-      recurringAmount: strictNumber.default(2),
-      shippingTitle: import_zod37.z.string().default("Shipping Fees"),
-      type: import_zod37.z.enum(["free", "fixed_amount"]).default("free")
-    })
-  }).optional().default({
-    discount: {
-      amount: 30,
-      shouldShowSavingText: true,
-      type: "none"
-    },
-    shipping: {
-      amount: 1,
-      /** This isn't configurable in the admin-nextjs editor */
-      enabled: true,
-      /** This isn't configurable in the admin-nextjs editor */
-      recurringAmount: 2,
-      shippingTitle: "Shipping Fees",
-      type: "free"
-    }
-  }),
-  subscriptionIsDefault: import_zod37.z.boolean().optional(),
-  /** This isn't configurable in the admin-nextjs editor */
-  template: import_zod37.z.string().optional().default(""),
-  type: import_zod37.z.literal("shopify_post_purchase_extension").default("shopify_post_purchase_extension"),
-  upgradeToSubscription: import_zod37.z.object({
-    acceptButtonText: import_zod37.z.string().optional().default("Upgrade"),
-    allow: import_zod37.z.boolean().optional().default(false),
-    emailRefundNotice: import_zod37.z.boolean().optional().default(false),
-    errorBannerText: import_zod37.z.string().optional().default("This subscription cannot be added - limit one per order")
-  }).optional().default(() => ({
-    acceptButtonText: "Upgrade",
-    allow: false,
-    emailRefundNotice: false,
-    errorBannerText: "This subscription cannot be added - limit one per order"
-  }))
+  });
+  return CABLayoutSection.parse({ alignment: { horizontal }, sections });
+};
+
+// src/transforms/postPurchase/imageContentSettings.ts
+var import_zod43 = require("zod");
+var ImageContentSettings = ImageContentBlock.shape.settings.pick({
+  descriptionSize: true,
+  horizontalAlignment: true,
+  superTitleSize: true,
+  swapContent: true,
+  titleSize: true
+}).extend({
+  alt: import_zod43.z.unknown().optional(),
+  description: import_zod43.z.unknown().optional(),
+  image: import_zod43.z.unknown().optional(),
+  imagePlacement: ImageContentBlock.shape.settings.shape.imagePlacement.unwrap().nullable(),
+  imageSize: ImageContentBlock.shape.settings.shape.imageSize.pipe(import_zod43.z.number().positive()),
+  superTitle: import_zod43.z.unknown().optional(),
+  title: import_zod43.z.unknown().optional()
 });
 
+// src/transforms/postPurchase/convertImageContentBlock.ts
+var Shell2 = import_zod44.z.object({ settings: ImageContentSettings, type: import_zod44.z.literal("image_content") });
+var PROPORTIONAL_BREAK_AT = 500;
+var convertImageContentBlock = (raw, report) => {
+  const shell = Shell2.safeParse(raw);
+  if (!shell.success) {
+    report?.({ detail: "Unreadable post-purchase image-content block", kind: "section" });
+    return [];
+  }
+  const settings = shell.data.settings;
+  const alt = typeof settings.alt === "string" ? settings.alt : void 0;
+  if (settings.alt !== void 0 && alt === void 0) {
+    report?.({ detail: "Unreadable post-purchase image-content alt text", kind: "section" });
+  }
+  const image = convertImageFrame({ alt, image: settings.image, imageSize: settings.imageSize });
+  if (!image) report?.({ detail: "Unreadable post-purchase image-content image", kind: "section" });
+  const text2 = convertImageContentText(settings, report);
+  const textFrame = CABLayoutSection.parse({ direction: "grid", grid: { columns: ["100%"] }, sections: [text2] });
+  const placement = settings.imagePlacement ?? (settings.swapContent ? "right" : "left");
+  const imageFirst = placement === "left" || placement === "top";
+  const sections = imageFirst ? [image, textFrame] : [textFrame, image];
+  const ordered = sections.filter((section) => section !== null);
+  const inner = placement === "left" || placement === "right" ? CABLayoutSection.parse({
+    sections: ordered,
+    spacing: "loose",
+    wrapping: {
+      breakAt: settings.imageSize <= 1 ? PROPORTIONAL_BREAK_AT : settings.imageSize,
+      maxPerLine: 2
+    }
+  }) : CABLayoutSection.parse({
+    direction: "grid",
+    grid: { columns: ["100%"] },
+    sections: [CABLayoutSection.parse({ sections: ordered })],
+    width: 95
+  });
+  return [CABLayoutSection.parse({ frame: "offer-content", sections: [inner], spacing: "none" })];
+};
+
+// src/transforms/postPurchase/productCardPay.ts
+var import_es_toolkit6 = require("es-toolkit");
+var PAY_NOW = { en: "Pay Now" };
+var DECLINE_THIS_OFFER = { en: "Decline this offer" };
+var NOT_AVAILABLE_DEFAULTS = ["Not available"];
+var soldOutSlot = ({ language: language3 }) => labelSlot("soldOut", OFFER_LABELS.soldOut, language3.global.notAvailable, [], NOT_AVAILABLE_DEFAULTS);
+var productCardPay = (settings) => {
+  const payNow = labelSlot("payNow", PAY_NOW, settings.language.global.payNow);
+  const priced = settings.language.displayCtaPrice ? { ...payNow, content: (0, import_es_toolkit6.mapValues)(payNow.content, (label2) => `${label2} \xB7 {{total}}`) } : payNow;
+  return [addToOrderButton("primary", [priced, soldOutSlot(settings)])];
+};
+var productCardDecline = ({ language: language3 }) => [
+  {
+    action: "declineOffer",
+    buttonStyle: "secondary",
+    sections: [labelSlot("declineOffer", DECLINE_THIS_OFFER, language3.global.declineThisOffer)],
+    sectionType: "button"
+  }
+];
+
 // src/transforms/postPurchase/productCardSettings.ts
+var import_es_toolkit7 = require("es-toolkit");
+var import_zod45 = require("zod");
 var { shape } = PostPurchaseSettings;
-var Labels = import_zod38.z.object(
+var Labels = import_zod45.z.object(
   (0, import_es_toolkit7.mapValues)(shape.language.shape.global.unwrap().unwrap().shape, (label2) => label2.catch(() => label2.parse(void 0)))
 );
-var Language = import_zod38.z.object({
+var Language = import_zod45.z.object({
   displayCtaPrice: shape.language.shape.displayCtaPrice.catch(true),
   global: Labels.catch(() => Labels.parse({}))
 });
-var Fields = import_zod38.z.object({
+var Fields = import_zod45.z.object({
   discount: shape.discount.catch(() => shape.discount.parse({})),
   language: Language.catch(() => Language.parse({})),
   productOptions: shape.productOptions.catch(() => shape.productOptions.parse({})),
@@ -4796,7 +5018,7 @@ var convertSeparatorBlock = (raw, report) => {
 };
 
 // src/transforms/postPurchase/convertTextBlock.ts
-var import_zod39 = require("zod");
+var import_zod46 = require("zod");
 var fields3 = ["superTitle", "title", "description"];
 var styles = {
   description: [{ attrs: { color: "base", fontSize: "small" }, type: "textStyle" }],
@@ -4804,13 +5026,13 @@ var styles = {
   title: [{ type: "bold" }, { attrs: { color: "base", fontSize: "large" }, type: "textStyle" }]
 };
 var settingsSchema = TextBlock.shape.settings;
-var Shell3 = import_zod39.z.object({
+var Shell3 = import_zod46.z.object({
   settings: settingsSchema.pick({ horizontalAlignment: true }).extend({
-    description: import_zod39.z.unknown().optional(),
-    superTitle: import_zod39.z.unknown().optional(),
-    title: import_zod39.z.unknown().optional()
+    description: import_zod46.z.unknown().optional(),
+    superTitle: import_zod46.z.unknown().optional(),
+    title: import_zod46.z.unknown().optional()
   }),
-  type: import_zod39.z.literal("text")
+  type: import_zod46.z.literal("text")
 });
 var convertTextBlock = (raw, report) => {
   const shell = Shell3.safeParse(raw);
@@ -4882,11 +5104,11 @@ var convertTimerBlock = (raw, report) => {
 };
 
 // src/transforms/postPurchase/convertMessagePreview.ts
-var MessageWidget = import_zod40.z.object({
-  blocks: import_zod40.z.array(import_zod40.z.unknown()).min(1),
-  type: import_zod40.z.literal(WidgetType.shopify_post_purchase_extension)
+var MessageWidget = import_zod47.z.object({
+  blocks: import_zod47.z.array(import_zod47.z.unknown()).min(1),
+  type: import_zod47.z.literal(WidgetType.shopify_post_purchase_extension)
 });
-var BlockType2 = import_zod40.z.object({ type: import_zod40.z.string() });
+var BlockType2 = import_zod47.z.object({ type: import_zod47.z.string() });
 var converters = {
   callout_banner: convertCalloutBlock,
   image: convertImageBlock,
@@ -5398,6 +5620,12 @@ var reportUnreadableVerdict = (metadata, report) => {
   if (RuleVerdict.safeParse(metadata).success || isDefinitiveRuleAnswer(metadata)) return;
   report?.({ detail: "rule verdict lacks readable custom.shouldShow", kind: "ruleVerdict" });
 };
+var withReviews = (product, integrations, report) => {
+  const { reviews: engineReviews, ...rest } = product;
+  const reviews = projectOfferProductReviews(integrations, product, report);
+  if (reviews !== void 0) return { ...rest, reviews };
+  return engineReviews === void 0 ? product : rest;
+};
 var dedupeById = (products) => (0, import_es_toolkit8.uniqBy)(products, (product) => product.id);
 var MAX_REQUEST_LINE_BYTES = 32e3;
 var requestLineBytes = (path, search) => new TextEncoder().encode(`GET ${path}?${search} HTTP/1.1`).length;
@@ -5424,7 +5652,9 @@ var fetchDataSourceResults = async (input, ctx) => {
   if (input.limit === 0) reportUnreadableVerdict(metadata, ctx.reportDrift);
   if (input.limit !== 0 && (upstream != null && (typeof upstream !== "object" || Array.isArray(upstream)) || raw.data != null && !Array.isArray(raw.data)))
     ctx.reportDrift?.({ detail: "data-source products payload is not an array", kind: "dataSource" });
-  const products = dedupeById(rawProducts.filter((product) => keepValidProduct(product, ctx.reportDrift)));
+  const products = dedupeById(rawProducts.filter((product) => keepValidProduct(product, ctx.reportDrift))).map(
+    (product) => withReviews(product, input.integrations, ctx.reportDrift)
+  );
   return {
     metadata,
     /** B2B sessions filter by the company-location catalog server-side (the client bypasses its market hide). */
@@ -5434,7 +5664,7 @@ var fetchDataSourceResults = async (input, ctx) => {
 };
 
 // src/server/adsEngine.ts
-var import_zod41 = require("zod");
+var import_zod48 = require("zod");
 var SUPPLY_KEY = { production: "AQF5RKLR", staging: "Z56LQ7PS" };
 var OFFER_LIMIT = 4;
 var SUPPORTED_COUNTRIES = /* @__PURE__ */ new Set(["US", "CA", "GB"]);
@@ -5447,30 +5677,30 @@ var transactionItems = (input) => (input.transactionItems?.map(({ id, priceCents
   title,
   type
 })) ?? input.cart.items.map(({ productId: productId2, quantity: quantity3 }) => ({ id: productId2, quantity: quantity3 }))).slice(0, MAX_TRANSACTION_ITEMS);
-var AdsEngineOffer = import_zod41.z.object({
+var AdsEngineOffer = import_zod48.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_zod41.z.string().catch(""),
-  click_url: import_zod41.z.string(),
-  cta: import_zod41.z.string(),
+  callout: import_zod48.z.string().catch(""),
+  click_url: import_zod48.z.string(),
+  cta: import_zod48.z.string(),
   /** `omitempty` on the ad server — a bid without it must not fail the parse and drop the whole batch (composeOffer falls back to 'No Thanks'). */
-  decline_cta: import_zod41.z.string().catch(""),
-  decline_url: import_zod41.z.string(),
-  description: import_zod41.z.string(),
+  decline_cta: import_zod48.z.string().catch(""),
+  decline_url: import_zod48.z.string(),
+  description: import_zod48.z.string(),
   /** Short legal disclosure (FDIC / auto-renewal / FTC-affiliation lines). Rendered subdued under the CTAs. */
-  disclaimer: import_zod41.z.string().catch(""),
+  disclaimer: import_zod48.z.string().catch(""),
   /** Long legal text behind the disclosure toggle in the composed card (REB-24429). */
-  extended_disclaimer: import_zod41.z.string().catch(""),
-  headline: import_zod41.z.string(),
-  id: import_zod41.z.string(),
+  extended_disclaimer: import_zod48.z.string().catch(""),
+  headline: import_zod48.z.string(),
+  id: import_zod48.z.string(),
   /** Advertiser-supplied image alt; the composed card falls back to the stripped headline when empty. */
-  image_alt: import_zod41.z.string().catch(""),
-  image_url: import_zod41.z.string().optional(),
+  image_alt: import_zod48.z.string().catch(""),
+  image_url: import_zod48.z.string().optional(),
   /** The serving network's own privacy page (Falcon, REB-24744); the card prefers it over the widget setting. A bad value drops only this field, never the offer. */
-  privacy_url: import_zod41.z.string().optional().catch(void 0),
-  view_url: import_zod41.z.string()
+  privacy_url: import_zod48.z.string().optional().catch(void 0),
+  view_url: import_zod48.z.string()
 });
-var AdsEngineResponse = import_zod41.z.object({
-  offers: import_zod41.z.array(import_zod41.z.unknown()).default([]).transform(
+var AdsEngineResponse = import_zod48.z.object({
+  offers: import_zod48.z.array(import_zod48.z.unknown()).default([]).transform(
     (offers) => offers.flatMap((offer) => {
       const result = AdsEngineOffer.safeParse(offer);
       return result.success ? [result.data] : [];
@@ -5482,8 +5712,8 @@ var AdsEngineResponse = import_zod41.z.object({
    * offers-testing fixture on a test store forces it, REB-24467). Both optional: an older engine or a
    * non-JSON body must not fail the parse and drop the offers.
    */
-  request_id: import_zod41.z.string().optional().catch(void 0),
-  testing: import_zod41.z.boolean().optional().catch(void 0)
+  request_id: import_zod48.z.string().optional().catch(void 0),
+  testing: import_zod48.z.boolean().optional().catch(void 0)
 });
 var adsHost = (host) => `offers.${host}`;
 var isTestingRequest = (input, isProduction) => !isProduction || !!input.testing || input.customerEmail?.toLowerCase() === TEST_CUSTOMER_EMAIL;
@@ -5799,7 +6029,6 @@ var fetchMonetizeOffers = async (input, ctx, prefetched) => {
 
 // src/server/salvageSections.ts
 var import_uuid16 = require("uuid");
-var STUB_SECTION_TYPE = "unknown";
 var knownSectionTypes = new Set(sectionTypes);
 var hasSectionsArray = (raw) => typeof raw === "object" && raw !== null && Array.isArray(raw.sections);
 var stubSection = (raw, report) => {
@@ -5812,7 +6041,7 @@ var stubSection = (raw, report) => {
   });
   return {
     sectionId: typeof rawId === "string" && rawId ? rawId : (0, import_uuid16.v7)(),
-    sectionType: typeof original === "string" && !knownSectionTypes.has(original) ? original : STUB_SECTION_TYPE
+    sectionType: typeof original === "string" && !knownSectionTypes.has(original) ? original : SALVAGED_SECTION_TYPE
   };
 };
 var salvageSection = (raw, report) => {
@@ -5955,13 +6184,13 @@ var convertWidgetSettings = async (input, ctx) => {
 };
 
 // src/server/giftWidgets.ts
-var import_zod42 = require("zod");
-var SettingsNumber = import_zod42.z.union([
-  import_zod42.z.number(),
-  import_zod42.z.string().trim().regex(/^-?\d+(\.\d+)?$/)
-]).pipe(import_zod42.z.coerce.number());
-var SgwpMilestoneSchema = import_zod42.z.object({
-  selectable_product_quantity: SettingsNumber.pipe(import_zod42.z.number().int().nonnegative()),
+var import_zod49 = require("zod");
+var SettingsNumber = import_zod49.z.union([
+  import_zod49.z.number(),
+  import_zod49.z.string().trim().regex(/^-?\d+(\.\d+)?$/)
+]).pipe(import_zod49.z.coerce.number());
+var SgwpMilestoneSchema = import_zod49.z.object({
+  selectable_product_quantity: SettingsNumber.pipe(import_zod49.z.number().int().nonnegative()),
   unlock_price: SettingsNumber
 });
 var fetchGiftWidgetSettings = async (widgetId, shop, ctx) => unwrapData(await ctx.fetchUpstream("/api/v1/widgets/settings", { id: String(widgetId), shop }, { host: ctx.host }));
@@ -5972,7 +6201,7 @@ var readDataSourcePath = (settings) => {
 var readMilestones = (settings, report) => {
   const raw = settings && typeof settings === "object" ? settings.milestones : void 0;
   if (raw == null) return [];
-  const parsed = import_zod42.z.array(SgwpMilestoneSchema).safeParse(raw);
+  const parsed = import_zod49.z.array(SgwpMilestoneSchema).safeParse(raw);
   if (parsed.success) return parsed.data;
   report?.({
     detail: [
@@ -6087,16 +6316,16 @@ var validateGifts = async (input, ctx) => {
 
 // src/server/normalizePostPurchaseProduct.ts
 var import_compat7 = require("es-toolkit/compat");
-var import_zod46 = require("zod");
+var import_zod53 = require("zod");
 
 // src/schema/postPurchaseProductSettings.ts
-var import_zod44 = require("zod");
+var import_zod51 = require("zod");
 
 // src/schema/postPurchaseProductSource.ts
-var import_zod43 = require("zod");
-var PostPurchaseAmount = import_zod43.z.string().regex(/^\d+(?:\.\d+)?$/).refine((value) => Number.isFinite(Number(value)));
-var PostPurchaseProductId = import_zod43.z.number().int().positive();
-var PostPurchaseVariantId = import_zod43.z.number().int().positive();
+var import_zod50 = require("zod");
+var PostPurchaseAmount = import_zod50.z.string().regex(/^\d+(?:\.\d+)?$/).refine((value) => Number.isFinite(Number(value)));
+var PostPurchaseProductId = import_zod50.z.number().int().positive();
+var PostPurchaseVariantId = import_zod50.z.number().int().positive();
 var ProductBase = OfferProduct.pick({ description: true, id: true, image: true, title: true }).extend({
   description: OfferProduct.shape.description.nullable(),
   id: PostPurchaseProductId
@@ -6104,51 +6333,51 @@ var ProductBase = OfferProduct.pick({ description: true, id: true, image: true,
 var SourceVariant = OfferProduct.shape.variants.element.pick({ id: true, title: true }).extend({
   compareAtPrice: PostPurchaseAmount.nullable(),
   id: PostPurchaseVariantId,
-  imageId: import_zod43.z.number().int().nonnegative().nullish(),
-  inventoryManagement: import_zod43.z.string().nullable(),
-  inventoryPolicy: import_zod43.z.string(),
-  inventoryQuantity: import_zod43.z.number(),
-  option1: import_zod43.z.unknown().optional(),
-  option2: import_zod43.z.unknown().optional(),
-  option3: import_zod43.z.unknown().optional(),
+  imageId: import_zod50.z.number().int().nonnegative().nullish(),
+  inventoryManagement: import_zod50.z.string().nullable(),
+  inventoryPolicy: import_zod50.z.string(),
+  inventoryQuantity: import_zod50.z.number(),
+  option1: import_zod50.z.unknown().optional(),
+  option2: import_zod50.z.unknown().optional(),
+  option3: import_zod50.z.unknown().optional(),
   price: PostPurchaseAmount,
   productId: PostPurchaseProductId,
-  sellingPlanAllocations: import_zod43.z.unknown().optional()
+  sellingPlanAllocations: import_zod50.z.unknown().optional()
 });
 var Product2 = ProductBase.extend({
-  images: import_zod43.z.array(
-    import_zod43.z.object({ alt: import_zod43.z.string().optional().catch(void 0), id: import_zod43.z.number().int().positive(), src: import_zod43.z.string() })
+  images: import_zod50.z.array(
+    import_zod50.z.object({ alt: import_zod50.z.string().optional().catch(void 0), id: import_zod50.z.number().int().positive(), src: import_zod50.z.string() })
   ).nullish(),
-  metadata: import_zod43.z.object({
-    productQuantity: import_zod43.z.union([
-      import_zod43.z.number().int().positive(),
-      import_zod43.z.string().regex(/^[1-9]\d*$/).transform(Number)
+  metadata: import_zod50.z.object({
+    productQuantity: import_zod50.z.union([
+      import_zod50.z.number().int().positive(),
+      import_zod50.z.string().regex(/^[1-9]\d*$/).transform(Number)
     ]).optional()
   }).optional(),
-  metafields: import_zod43.z.unknown().optional(),
-  options: import_zod43.z.unknown().optional(),
-  productGroupVariants: import_zod43.z.array(import_zod43.z.unknown()).default([]),
+  metafields: import_zod50.z.unknown().optional(),
+  options: import_zod50.z.unknown().optional(),
+  productGroupVariants: import_zod50.z.array(import_zod50.z.unknown()).default([]),
   // REB-25048: the v2 data source flags a subscription-only product here and sends no selling plan groups
-  requiresSellingPlan: import_zod43.z.boolean().nullish(),
-  selectedVariant: import_zod43.z.unknown().optional(),
-  sellingPlanGroups: import_zod43.z.array(
+  requiresSellingPlan: import_zod50.z.boolean().nullish(),
+  selectedVariant: import_zod50.z.unknown().optional(),
+  sellingPlanGroups: import_zod50.z.array(
     OfferProduct.shape.sellingPlanGroups.unwrap().element.extend({
-      discountAmount: import_zod43.z.unknown().optional(),
-      discountType: import_zod43.z.unknown().optional(),
-      id: import_zod43.z.unknown().optional(),
-      requiresSellingPlan: import_zod43.z.boolean().default(false),
-      sellingPlans: import_zod43.z.unknown().optional()
+      discountAmount: import_zod50.z.unknown().optional(),
+      discountType: import_zod50.z.unknown().optional(),
+      id: import_zod50.z.unknown().optional(),
+      requiresSellingPlan: import_zod50.z.boolean().default(false),
+      sellingPlans: import_zod50.z.unknown().optional()
     })
   ).default([]),
-  variants: import_zod43.z.array(SourceVariant)
+  variants: import_zod50.z.array(SourceVariant)
 });
-var PostPurchaseProductSource = import_zod43.z.object({
-  data: import_zod43.z.array(Product2),
-  metadata: import_zod43.z.object({ widget: import_zod43.z.record(import_zod43.z.string(), import_zod43.z.unknown()).default({}) }).default({ widget: {} })
+var PostPurchaseProductSource = import_zod50.z.object({
+  data: import_zod50.z.array(Product2),
+  metadata: import_zod50.z.object({ widget: import_zod50.z.record(import_zod50.z.string(), import_zod50.z.unknown()).default({}) }).default({ widget: {} })
 });
 
 // src/schema/postPurchaseProductSettings.ts
-var amount = import_zod44.z.union([import_zod44.z.number().nonnegative(), PostPurchaseAmount.transform(Number)]);
+var amount = import_zod51.z.union([import_zod51.z.number().nonnegative(), PostPurchaseAmount.transform(Number)]);
 var PostPurchaseProductSettings = PostPurchaseSettings.pick({
   discountedFrom: true,
   language: true,
@@ -6160,18 +6389,18 @@ var PostPurchaseProductSettings = PostPurchaseSettings.pick({
   subscriptionIsDefault: true,
   upgradeToSubscription: true
 }).extend({
-  advance: import_zod44.z.unknown().default({}),
-  blocks: import_zod44.z.array(import_zod44.z.unknown()).optional(),
+  advance: import_zod51.z.unknown().default({}),
+  blocks: import_zod51.z.array(import_zod51.z.unknown()).optional(),
   discount: PostPurchaseSettings.shape.discount.extend({ amount: amount.default(30) }),
-  integrations: import_zod44.z.unknown().default({}),
+  integrations: import_zod51.z.unknown().default({}),
   shipping: PostPurchaseSettings.shape.shipping.extend({ amount: amount.default(10) }),
-  styles: import_zod44.z.unknown().default({}),
+  styles: import_zod51.z.unknown().default({}),
   subImages: PostPurchaseSettings.shape.subImages.catch(null),
-  subscription: import_zod44.z.unknown().default(PostPurchaseSettings.shape.subscription.parse(void 0))
+  subscription: import_zod51.z.unknown().default(PostPurchaseSettings.shape.subscription.parse(void 0))
 });
 
 // src/server/readPostPurchaseProductSource.ts
-var import_zod45 = require("zod");
+var import_zod52 = require("zod");
 
 // src/server/postPurchaseResponseDrift.ts
 var heard = /* @__PURE__ */ new WeakMap();
@@ -6197,9 +6426,9 @@ var requiresOwnSellingPlan = (product) => product.requiresSellingPlan === true;
 var requiresUnsuppliedSellingPlan = (product) => requiresOwnSellingPlan(product) && !product.sellingPlanGroups?.length;
 
 // src/server/readPostPurchaseProductSource.ts
-var Envelope = PostPurchaseProductSource.extend({ data: import_zod45.z.array(import_zod45.z.unknown()) });
+var Envelope = PostPurchaseProductSource.extend({ data: import_zod52.z.array(import_zod52.z.unknown()) });
 var Product3 = PostPurchaseProductSource.shape.data.element;
-var Identified = import_zod45.z.object({ id: PostPurchaseProductId });
+var Identified = import_zod52.z.object({ id: PostPurchaseProductId });
 var readPostPurchaseProductSource = (response, report) => {
   const { data, metadata } = Envelope.parse(deepCamelCase(response));
   const drift = [];
@@ -6234,9 +6463,9 @@ var normalizePostPurchaseSource = (settings, response, report) => {
   const original = PostPurchaseProductSettings.parse(deepCamelCase(settings));
   const { dropped, metadata, products } = readPostPurchaseProductSource(response, report);
   const overrides = Object.fromEntries(Object.entries(metadata.widget).filter(([key]) => key in original));
-  const discount = import_zod46.z.object({ type: import_zod46.z.string() }).safeParse(overrides.discount);
+  const discount = import_zod53.z.object({ type: import_zod53.z.string() }).safeParse(overrides.discount);
   if (discount.success && discount.data.type === "fixed") {
-    overrides.discount = { ...import_zod46.z.record(import_zod46.z.string(), import_zod46.z.unknown()).parse(overrides.discount), type: "fixed_amount" };
+    overrides.discount = { ...import_zod53.z.record(import_zod53.z.string(), import_zod53.z.unknown()).parse(overrides.discount), type: "fixed_amount" };
   }
   const effective = PostPurchaseProductSettings.parse((0, import_compat7.merge)({}, original, overrides));
   const data = products.map(({ product }) => product);
@@ -6273,52 +6502,52 @@ var postPurchasePlanDiscountPercentage = (price, adjustment) => {
 };
 
 // src/schema/postPurchasePlanCatalog.ts
-var import_zod49 = require("zod");
+var import_zod56 = require("zod");
 
 // src/schema/postPurchasePlanAdjustment.ts
-var import_zod48 = require("zod");
+var import_zod55 = require("zod");
 
 // src/schema/postPurchaseDiscount.ts
-var import_zod47 = require("zod");
-var Discount = import_zod47.z.object({
-  amount: import_zod47.z.number().nonnegative(),
-  title: import_zod47.z.string(),
-  type: import_zod47.z.enum(["none", "fixed_amount", "percentage"])
+var import_zod54 = require("zod");
+var Discount = import_zod54.z.object({
+  amount: import_zod54.z.number().nonnegative(),
+  title: import_zod54.z.string(),
+  type: import_zod54.z.enum(["none", "fixed_amount", "percentage"])
 });
 var validPostPurchaseDiscount = (discount) => discount.type !== "percentage" || discount.amount <= 100;
 var PostPurchaseDiscount = Discount.refine(validPostPurchaseDiscount);
 
 // src/schema/postPurchasePlanAdjustment.ts
-var PostPurchasePlanAdjustment = import_zod48.z.object({
+var PostPurchasePlanAdjustment = import_zod55.z.object({
   amount: PostPurchaseDiscount.shape.amount,
-  type: import_zod48.z.enum(["percentage", "fixed_amount", "price"])
+  type: import_zod55.z.enum(["percentage", "fixed_amount", "price"])
 }).refine(({ amount: amount2, type }) => type === "price" || validPostPurchaseDiscount({ amount: amount2, type }));
 
 // src/schema/postPurchasePlanCatalog.ts
-var PostPurchasePlanOption = import_zod49.z.object({
+var PostPurchasePlanOption = import_zod56.z.object({
   adjustment: PostPurchasePlanAdjustment.optional(),
   /** cab-checkout's `discountPercentage`: the plan's own whole-percent saving on the regular price (`{{subscriptionDiscount}}`). */
-  discountPercentage: import_zod49.z.number().int().min(0).max(100).optional(),
-  id: import_zod49.z.number().int().positive(),
-  intervalFrequency: import_zod49.z.string().regex(/^[1-9]\d*$/).optional(),
-  intervalLabel: import_zod49.z.string().min(1),
-  name: import_zod49.z.string().min(1)
+  discountPercentage: import_zod56.z.number().int().min(0).max(100).optional(),
+  id: import_zod56.z.number().int().positive(),
+  intervalFrequency: import_zod56.z.string().regex(/^[1-9]\d*$/).optional(),
+  intervalLabel: import_zod56.z.string().min(1),
+  name: import_zod56.z.string().min(1)
 });
-var PostPurchasePlanCatalog = import_zod49.z.object({
-  plans: import_zod49.z.array(PostPurchasePlanOption),
-  productId: import_zod49.z.number().int().positive(),
-  requiresSellingPlan: import_zod49.z.boolean(),
-  variantId: import_zod49.z.number().int().positive()
+var PostPurchasePlanCatalog = import_zod56.z.object({
+  plans: import_zod56.z.array(PostPurchasePlanOption),
+  productId: import_zod56.z.number().int().positive(),
+  requiresSellingPlan: import_zod56.z.boolean(),
+  variantId: import_zod56.z.number().int().positive()
 });
 
 // src/server/postPurchaseLegacyPlans.ts
-var import_zod51 = require("zod");
+var import_zod58 = require("zod");
 
 // src/server/postPurchasePlanAdjustment.ts
-var import_zod50 = require("zod");
-var SourceAdjustment = import_zod50.z.object({
+var import_zod57 = require("zod");
+var SourceAdjustment = import_zod57.z.object({
   amount: PostPurchaseProductSettings.shape.discount.shape.amount.unwrap(),
-  type: import_zod50.z.enum(["percentage", "fixed_amount", "amount", "price", "none", "fixed"])
+  type: import_zod57.z.enum(["percentage", "fixed_amount", "amount", "price", "none", "fixed"])
 });
 var readPostPurchasePlanAdjustment = (raw) => {
   const source2 = SourceAdjustment.parse(raw);
@@ -6337,13 +6566,13 @@ var readPostPurchasePlanAdjustment = (raw) => {
 var Plan = PostPurchasePlanOption.pick({ id: true, name: true }).extend({
   orderIntervalFrequency: PostPurchasePlanOption.shape.intervalFrequency.unwrap(),
   orderIntervalUnitType: PostPurchasePlanOption.shape.intervalLabel,
-  shopifyVariantId: import_zod51.z.string().regex(/^[1-9]\d*$/).nullish()
+  shopifyVariantId: import_zod58.z.string().regex(/^[1-9]\d*$/).nullish()
 });
-var Group = import_zod51.z.object({
-  discountAmount: import_zod51.z.unknown(),
-  discountType: import_zod51.z.unknown(),
-  id: import_zod51.z.number().int().positive(),
-  sellingPlans: import_zod51.z.array(import_zod51.z.object({ shopifyVariantId: Plan.shape.shopifyVariantId }).passthrough())
+var Group = import_zod58.z.object({
+  discountAmount: import_zod58.z.unknown(),
+  discountType: import_zod58.z.unknown(),
+  id: import_zod58.z.number().int().positive(),
+  sellingPlans: import_zod58.z.array(import_zod58.z.object({ shopifyVariantId: Plan.shape.shopifyVariantId }).passthrough())
 });
 var readPostPurchaseLegacyPlans = (raw, variantId) => {
   const group = Group.pick({ id: true, sellingPlans: true }).parse(raw);
@@ -6364,22 +6593,22 @@ var readPostPurchaseLegacyPlans = (raw, variantId) => {
 };
 
 // src/server/postPurchaseModernPlans.ts
-var import_zod52 = require("zod");
-var Groups = import_zod52.z.array(
-  import_zod52.z.object({
-    id: import_zod52.z.string().min(1),
-    sellingPlans: import_zod52.z.unknown()
+var import_zod59 = require("zod");
+var Groups = import_zod59.z.array(
+  import_zod59.z.object({
+    id: import_zod59.z.string().min(1),
+    sellingPlans: import_zod59.z.unknown()
   })
 );
-var PostPurchasePlanAllocations = import_zod52.z.array(import_zod52.z.object({ sellingPlanGroupId: import_zod52.z.string().min(1) }));
+var PostPurchasePlanAllocations = import_zod59.z.array(import_zod59.z.object({ sellingPlanGroupId: import_zod59.z.string().min(1) }));
 var Allocations = PostPurchasePlanAllocations.default([]);
-var Plans = import_zod52.z.array(
+var Plans = import_zod59.z.array(
   PostPurchasePlanOption.pick({ id: true, name: true }).extend({
-    options: import_zod52.z.array(import_zod52.z.object({ value: import_zod52.z.string().min(1) })).min(1),
-    priceAdjustments: import_zod52.z.array(import_zod52.z.unknown())
+    options: import_zod59.z.array(import_zod59.z.object({ value: import_zod59.z.string().min(1) })).min(1),
+    priceAdjustments: import_zod59.z.array(import_zod59.z.unknown())
   })
 );
-var FirstAdjustment = import_zod52.z.object({
+var FirstAdjustment = import_zod59.z.object({
   value: PostPurchaseProductSettings.shape.discount.shape.amount.unwrap(),
   valueType: PostPurchasePlanAdjustment.shape.type
 });
@@ -6437,72 +6666,45 @@ var projectPostPurchasePlanCatalog = (normalized, report) => {
 };
 
 // src/schema/postPurchaseSubscriptionProduct.ts
-var import_zod58 = require("zod");
+var import_zod64 = require("zod");
 
 // src/schema/postPurchaseProduct.ts
-var import_zod57 = require("zod");
+var import_zod63 = require("zod");
 
 // src/schema/postPurchaseProductDisplay.ts
-var import_zod55 = require("zod");
+var import_zod61 = require("zod");
 
 // src/schema/postPurchaseProductGallery.ts
-var import_zod53 = require("zod");
-var PostPurchaseProductGallery = import_zod53.z.object({
+var import_zod60 = require("zod");
+var PostPurchaseProductGallery = import_zod60.z.object({
   /**
    * Show the thumbnail row: the product had more than one image before `images` was capped at the
    * sub-image limit, and that limit allows at least one thumbnail. It stays true when the cap leaves one
    * image (legacy checks the count before slicing). Older replies omit it; fall back to `images.length > 1`.
    */
-  hasMultiple: import_zod53.z.boolean().optional(),
-  images: import_zod53.z.array(
-    import_zod53.z.object({
-      description: import_zod53.z.string(),
-      id: import_zod53.z.number().int().positive(),
-      source: import_zod53.z.string(),
-      thumbnail: import_zod53.z.string()
+  hasMultiple: import_zod60.z.boolean().optional(),
+  images: import_zod60.z.array(
+    import_zod60.z.object({
+      description: import_zod60.z.string(),
+      id: import_zod60.z.number().int().positive(),
+      source: import_zod60.z.string(),
+      thumbnail: import_zod60.z.string()
     })
   ),
-  selectedImageId: import_zod53.z.number().int().positive().optional()
-});
-
-// src/schema/postPurchaseProductReviews.ts
-var import_zod54 = require("zod");
-var decimal = import_zod54.z.union([
-  import_zod54.z.number(),
-  import_zod54.z.string().regex(/^\d+(?:\.\d+)?$/).transform(Number)
-]);
-var PostPurchaseCommonReviewRating = import_zod54.z.object({ value: decimal.pipe(import_zod54.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_zod54.z.unknown().nonoptional(),
-  scale_min: import_zod54.z.unknown().nonoptional()
-});
-var PostPurchaseReviewCount = import_zod54.z.string().regex(/^\d+(?:\.\d+)?$/).transform(Number).pipe(import_zod54.z.number().int().nonnegative());
-var PostPurchaseReviewStyles = PostPurchaseSettings.shape.styles.unwrap().extend({
-  strokeWidth: decimal.pipe(import_zod54.z.number().nonnegative()).default(1)
-}).prefault({});
-var PostPurchaseProductReviews = import_zod54.z.object({
-  color: import_zod54.z.string(),
-  rating: import_zod54.z.number().positive().max(5),
-  reviewCount: import_zod54.z.number().int().nonnegative(),
-  reviewsPlural: import_zod54.z.string(),
-  reviewsSingular: import_zod54.z.string(),
-  size: import_zod54.z.enum(["small", "medium", "large"]),
-  strokeColor: import_zod54.z.string(),
-  strokeWidth: import_zod54.z.number().nonnegative()
+  selectedImageId: import_zod60.z.number().int().positive().optional()
 });
 
 // src/schema/postPurchaseProductDisplay.ts
 var language = PostPurchaseSettings.shape.language;
-var PostPurchasePrimaryImageSource = import_zod55.z.string().default(
+var PostPurchasePrimaryImageSource = import_zod61.z.string().default(
   "https://cdn.shopify.com/shopifycloud/shopify/assets/no-image-2048-5e88c1b20e087fb7bbe9a3771824e743c244f437e4f8ba93bbf7b11b53f7824c.gif"
 );
-var PostPurchaseProductDisplay = import_zod55.z.object({
+var PostPurchaseProductDisplay = import_zod61.z.object({
   descriptionDocument: TiptapDocument.optional(),
   discountedFrom: PostPurchaseSettings.shape.discountedFrom,
   gallery: PostPurchaseProductGallery.optional(),
   language: language.pick({ description: true, descriptionEnabled: true }),
-  primaryImage: import_zod55.z.object({ description: import_zod55.z.string(), source: import_zod55.z.string() }),
+  primaryImage: import_zod61.z.object({ description: import_zod61.z.string(), source: import_zod61.z.string() }),
   productOptions: PostPurchaseSettings.shape.productOptions.pick({
     showDeclineAll: true,
     showShipping: true,
@@ -6517,16 +6719,16 @@ var PostPurchaseProductDisplay = import_zod55.z.object({
 });
 
 // src/schema/postPurchaseSubscription.ts
-var import_zod56 = require("zod");
-var PostPurchaseSubscriptionTerms = import_zod56.z.object({
+var import_zod62 = require("zod");
+var PostPurchaseSubscriptionTerms = import_zod62.z.object({
   adjustment: PostPurchasePlanAdjustment.optional(),
-  initialShippingPrice: import_zod56.z.number().nonnegative(),
-  intervalLabel: import_zod56.z.string().min(1),
-  name: import_zod56.z.string().min(1),
-  recurringShippingPrice: import_zod56.z.number().nonnegative(),
-  shippingOption: import_zod56.z.object({ presentmentTitle: import_zod56.z.string(), title: import_zod56.z.string() }),
+  initialShippingPrice: import_zod62.z.number().nonnegative(),
+  intervalLabel: import_zod62.z.string().min(1),
+  name: import_zod62.z.string().min(1),
+  recurringShippingPrice: import_zod62.z.number().nonnegative(),
+  shippingOption: import_zod62.z.object({ presentmentTitle: import_zod62.z.string(), title: import_zod62.z.string() }),
   /** A switch to subscription (STS): the one subscription that charges no initial shipping (L122). */
-  sts: import_zod56.z.literal(true).optional()
+  sts: import_zod62.z.literal(true).optional()
 });
 
 // src/schema/postPurchaseProduct.ts
@@ -6536,52 +6738,52 @@ var PostPurchaseVariant = OfferProduct.shape.variants.element.pick({ id: true, t
   id: PostPurchaseVariantId,
   price: PostPurchaseAmount
 });
-var PreparedPostPurchaseProduct = import_zod57.z.object({
+var PreparedPostPurchaseProduct = import_zod63.z.object({
   display: PostPurchaseProductDisplay,
-  labels: import_zod57.z.object({
+  labels: import_zod63.z.object({
     declineAll: global.declineAll,
-    free: import_zod57.z.string(),
+    free: import_zod63.z.string(),
     notAvailable: global.notAvailable,
-    payNow: import_zod57.z.string(),
-    quantity: import_zod57.z.string(),
+    payNow: import_zod63.z.string(),
+    quantity: import_zod63.z.string(),
     recurringShipping: global.recurringShipping,
     recurringSubtotal: global.recurringSubtotal,
-    save: import_zod57.z.string(),
-    shipping: import_zod57.z.string(),
-    subtotal: import_zod57.z.string(),
-    taxes: import_zod57.z.string(),
-    total: import_zod57.z.string()
+    save: import_zod63.z.string(),
+    shipping: import_zod63.z.string(),
+    subtotal: import_zod63.z.string(),
+    taxes: import_zod63.z.string(),
+    total: import_zod63.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_zod57.z.object({
+  selection: import_zod63.z.object({
     productId: PostPurchaseProductId,
-    quantity: import_zod57.z.number().int().positive(),
-    sellingPlanId: import_zod57.z.number().int().positive().optional(),
+    quantity: import_zod63.z.number().int().positive(),
+    sellingPlanId: import_zod63.z.number().int().positive().optional(),
     variantId: PostPurchaseVariantId
   }),
-  status: import_zod57.z.literal("prepared"),
-  terms: import_zod57.z.object({
+  status: import_zod63.z.literal("prepared"),
+  terms: import_zod63.z.object({
     discount: PostPurchaseDiscount,
-    shipping: import_zod57.z.object({
-      amount: import_zod57.z.number().nonnegative(),
-      title: import_zod57.z.string(),
-      type: import_zod57.z.enum(["free", "fixed_amount"])
+    shipping: import_zod63.z.object({
+      amount: import_zod63.z.number().nonnegative(),
+      title: import_zod63.z.string(),
+      type: import_zod63.z.enum(["free", "fixed_amount"])
     }),
     subscription: PostPurchaseSubscriptionTerms.optional()
   })
 });
-var PostPurchasePreparation = import_zod57.z.discriminatedUnion("status", [
+var PostPurchasePreparation = import_zod63.z.discriminatedUnion("status", [
   PreparedPostPurchaseProduct,
-  import_zod57.z.object({ reason: import_zod57.z.string(), status: import_zod57.z.literal("unsupported") })
+  import_zod63.z.object({ reason: import_zod63.z.string(), status: import_zod63.z.literal("unsupported") })
 ]);
 
 // src/schema/postPurchaseSubscriptionProduct.ts
 var PreparedPostPurchaseSubscription = PreparedPostPurchaseProduct.extend({
-  selection: PreparedPostPurchaseProduct.shape.selection.extend({ sellingPlanId: import_zod58.z.number().int().positive() }),
+  selection: PreparedPostPurchaseProduct.shape.selection.extend({ sellingPlanId: import_zod64.z.number().int().positive() }),
   terms: PreparedPostPurchaseProduct.shape.terms.extend({
     subscription: PostPurchaseSubscriptionTerms
   }).refine(
@@ -6641,7 +6843,7 @@ var subscriptionUnavailable = (normalized, plan, allowCollection, quantity3) =>
 };
 
 // src/server/postPurchaseProductDisplay.ts
-var import_zod60 = require("zod");
+var import_zod66 = require("zod");
 
 // src/server/postPurchasePrimaryImage.ts
 var postPurchasePrimaryImage = (product) => {
@@ -6667,7 +6869,7 @@ var postPurchaseProductGallery = (product, limit) => {
 };
 
 // src/transforms/postPurchase/convertDescriptionRte.ts
-var import_zod59 = require("zod");
+var import_zod65 = require("zod");
 var alignments = { center: "center", left: "start", right: "end" };
 var colors = ["critical", "subdued", "success", "warning"];
 var sizes2 = ["extraSmall", "small", "medium", "large", "extraLarge"];
@@ -6679,19 +6881,19 @@ var spacings2 = {
   xloose: "extraLoose",
   xtight: "extraTight"
 };
-var Block = import_zod59.z.object({
-  attrs: import_zod59.z.object({ alignment: import_zod59.z.enum(["left", "center", "right"]).optional().catch(void 0) }).catch({}),
-  content: import_zod59.z.array(import_zod59.z.unknown()).catch([]),
-  type: import_zod59.z.literal("ShopifyTextBlock")
-});
-var Run = import_zod59.z.object({ marks: import_zod59.z.array(import_zod59.z.unknown()).catch([]), text: import_zod59.z.string().min(1), type: import_zod59.z.literal("text") });
-var Inline = import_zod59.z.object({
-  attrs: import_zod59.z.object({
-    color: import_zod59.z.enum(colors).optional().catch(void 0),
-    emphasis: import_zod59.z.array(import_zod59.z.unknown()).catch([]),
-    size: import_zod59.z.enum(sizes2).optional().catch(void 0)
+var Block = import_zod65.z.object({
+  attrs: import_zod65.z.object({ alignment: import_zod65.z.enum(["left", "center", "right"]).optional().catch(void 0) }).catch({}),
+  content: import_zod65.z.array(import_zod65.z.unknown()).catch([]),
+  type: import_zod65.z.literal("ShopifyTextBlock")
+});
+var Run = import_zod65.z.object({ marks: import_zod65.z.array(import_zod65.z.unknown()).catch([]), text: import_zod65.z.string().min(1), type: import_zod65.z.literal("text") });
+var Inline = import_zod65.z.object({
+  attrs: import_zod65.z.object({
+    color: import_zod65.z.enum(colors).optional().catch(void 0),
+    emphasis: import_zod65.z.array(import_zod65.z.unknown()).catch([]),
+    size: import_zod65.z.enum(sizes2).optional().catch(void 0)
   }),
-  type: import_zod59.z.literal("ShopifyTextInline")
+  type: import_zod65.z.literal("ShopifyTextInline")
 });
 var marks = (raw) => {
   const found = raw.map((mark) => Inline.safeParse(mark)).find(({ success }) => success)?.data;
@@ -6724,7 +6926,7 @@ var convertDescriptionRte = (rte, spacing) => TiptapDocument.parse({
 });
 
 // src/server/postPurchaseProductDisplay.ts
-var ResponseLanguage = import_zod60.z.object({ description: PostPurchaseProductDisplay.shape.responseDescription }).default({ description: "" });
+var ResponseLanguage = import_zod66.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,
@@ -6736,146 +6938,6 @@ var projectPostPurchaseProductDisplay = (effective, metadata, product) => PostPu
   shouldShowSavingText: effective.discount.shouldShowSavingText
 });
 
-// src/server/postPurchaseReviewData.ts
-var import_zod65 = require("zod");
-
-// src/server/postPurchaseJudgeMeReviews.ts
-var import_zod62 = require("zod");
-
-// src/server/postPurchaseReviewFields.ts
-var import_zod61 = require("zod");
-var Field = import_zod61.z.object({ key: import_zod61.z.string(), namespace: import_zod61.z.string(), value: import_zod61.z.unknown().optional() });
-var reviewFields = (raw) => {
-  const fields4 = import_zod61.z.array(import_zod61.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);
-};
-var ReviewFieldError = class extends Error {
-  constructor(field) {
-    super(`Unreadable review field ${field}`);
-    this.field = field;
-  }
-};
-var readReviewField = (field, read) => {
-  try {
-    return read(field.value);
-  } catch {
-    throw new ReviewFieldError(`${field.namespace}.${field.key}`);
-  }
-};
-
-// src/server/postPurchaseJudgeMeReviews.ts
-var readJudgeMeReviews = (find) => {
-  const field = find("judgeme", "badge");
-  if (!field) return null;
-  return readReviewField(field, (value) => {
-    const html = import_zod62.z.string().parse(value);
-    const rating = html.match(/data-average-rating=['"](\d+(?:\.\d+)?)['"]/);
-    const count = html.match(/data-number-of-reviews=['"](\d+)['"]/);
-    if (!rating || !count) throw new Error("Unreadable Judge.me attributes");
-    return {
-      rating: PostPurchaseCommonReviewRating.parse({ value: rating[1] }).value,
-      reviewCount: PostPurchaseReviewCount.parse(count[1])
-    };
-  });
-};
-
-// src/server/postPurchaseOkendoReviews.ts
-var import_zod63 = require("zod");
-var Summary = import_zod63.z.object({
-  reviewAverageValue: PostPurchaseCommonReviewRating.shape.value,
-  reviewCount: import_zod63.z.union([PostPurchaseProductReviews.shape.reviewCount, PostPurchaseReviewCount])
-});
-var readOkendoReviews = (find) => {
-  const field = find("okendo", "summaryData");
-  if (!field) return null;
-  const summary = readReviewField(field, (value) => Summary.parse(JSON.parse(import_zod63.z.string().parse(value))));
-  return { rating: summary.reviewAverageValue, reviewCount: summary.reviewCount };
-};
-
-// src/server/postPurchaseScalarReviews.ts
-var import_zod64 = 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: readReviewField(
-      rating,
-      (value) => PostPurchaseCommonReviewRating.parse({ value: import_zod64.z.string().parse(value) }).value
-    ),
-    reviewCount: readReviewField(count, (value) => PostPurchaseReviewCount.parse(value))
-  };
-};
-
-// src/server/postPurchaseReviewData.ts
-var readStandardReviews = (find) => {
-  const rating = find("reviews", "rating");
-  const count = find("reviews", "rating_count");
-  if (!rating || !count) return null;
-  return {
-    rating: readReviewField(rating, (raw) => {
-      const value = import_zod65.z.string().parse(raw);
-      return PostPurchaseCommonReviewRating.parse(/^\d+(?:\.\d+)?$/.test(value) ? { value } : JSON.parse(value)).value;
-    }),
-    reviewCount: readReviewField(count, (value) => PostPurchaseReviewCount.parse(value))
-  };
-};
-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") ?? readStandardReviews(find);
-  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: readReviewField(
-      rating,
-      (value) => PostPurchaseKlaviyoReviewRating.parse(JSON.parse(import_zod65.z.string().parse(value))).value
-    ),
-    reviewCount: readReviewField(count, (value) => PostPurchaseReviewCount.parse(value))
-  };
-};
-
-// src/server/postPurchaseReviewProvider.ts
-var import_zod66 = require("zod");
-var IntegrationInput = import_zod66.z.record(import_zod66.z.string(), import_zod66.z.unknown()).prefault({});
-var precedence = [
-  "klaviyo",
-  "judgeme",
-  "junip",
-  "loox",
-  "okendo",
-  "opinew",
-  "reviewsio",
-  "stamped",
-  "yotpo"
-];
-var ReviewsIoFlag = import_zod66.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, { id: productId2, metafields }, report) => {
   try {