@rebuy/rebuy 3.60.5 → 3.62.0

package/dist/schema/widgets/checkout-and-beyond/progressBar.d.ts

@@ -5,16 +5,20 @@ import { type SectionDetails } from './shared';
  * One per-tier exclusion rule (onsite `getTierExclusionTotal`): cart lines matching the rule's `type` list
  * are subtracted from THIS tier's progress only, after the bar-level exclusions (gift lines, the exclusion
  * tag, `excludedVariantIds`) have already removed theirs — so a line is never double-counted. The client
- * resolves collections and tags per cart product from the Storefront API; `productIds` match the line's
- * product directly. Lists default empty so a rule always reads as "match nothing" rather than throwing.
+ * resolves collections and tags per cart product from the Storefront API; `products` match the line's
+ * product directly, narrowed to the entry's `variantIds` when it lists any. Lists default empty
+ * so a rule always reads as "match nothing" rather than throwing.
  */
 export declare const CABProgressTierExclusion: z.ZodObject<{
     collectionIds: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
-    productIds: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+    products: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        productId: z.ZodNumber;
+        variantIds: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+    }, z.core.$strip>>>;
     tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
     type: z.ZodEnum<{
-        tags: "tags";
         products: "products";
+        tags: "tags";
         collections: "collections";
     }>;
 }, z.core.$strip>;
@@ -29,11 +33,14 @@ export declare const CABProgressTier: z.ZodObject<{
     }, z.core.$strip>>;
     exclusions: z.ZodDefault<z.ZodArray<z.ZodObject<{
         collectionIds: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
-        productIds: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+        products: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            productId: z.ZodNumber;
+            variantIds: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+        }, z.core.$strip>>>;
         tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
         type: z.ZodEnum<{
-            tags: "tags";
             products: "products";
+            tags: "tags";
             collections: "collections";
         }>;
     }, z.core.$strip>>>;
@@ -373,11 +380,14 @@ export declare const CABProgressBarSection: z.ZodLazy<z.ZodObject<{
         }, z.core.$strip>>;
         exclusions: z.ZodDefault<z.ZodArray<z.ZodObject<{
             collectionIds: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
-            productIds: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+            products: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                productId: z.ZodNumber;
+                variantIds: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+            }, z.core.$strip>>>;
             tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
             type: z.ZodEnum<{
-                tags: "tags";
                 products: "products";
+                tags: "tags";
                 collections: "collections";
             }>;
         }, z.core.$strip>>>;

package/dist/server/index.cjs

@@ -1576,7 +1576,22 @@ var SmartCartTierProduct = import_zod19.z.looseObject({
 });
 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),
+  /**
+   * onsite keeps each excluded product with ITS OWN variants, the same shape the bar-level
+   * `excludedProducts` uses, so a rule can exclude one variant of B without touching A.
+   * Flat parallel id lists cannot express that mapping.
+   *
+   * camelCase like every other key in this file, NOT the `product_id` / `variant_ids` the onsite
+   * payload spells: `parseShielded` runs `deepCamelCase` over the tree BEFORE any schema sees it.
+   * A snake_case key here reads as absent, every entry drops, and the converter discards the whole
+   * rule in silence — the exclusion just never reaches checkout.
+   */
+  products: import_zod19.z.array(
+    import_zod19.z.looseObject({
+      productId: import_zod19.z.coerce.number().optional().catch(void 0),
+      variantIds: import_zod19.z.array(import_zod19.z.coerce.number()).optional().catch(void 0)
+    })
+  ).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)
 });
@@ -1711,6 +1726,7 @@ var SmartCartComponent = import_zod19.z.looseObject({
 var SmartCartConfig = import_zod19.z.looseObject({
   components: import_zod19.z.array(SmartCartComponent).optional()
 });
+var EngineSmartCart = import_zod19.z.preprocess((value) => value === false ? null : value, SmartCartConfig.nullish());
 
 // src/schema/cabShopConfig.ts
 var CabActiveExperiment = import_zod20.z.object({
@@ -1808,7 +1824,7 @@ var CabShopConfig = import_zod20.z.object({
 });
 var CabUserConfig = import_zod20.z.object({
   shop: CabShopConfig,
-  smartCart: SmartCartConfig.nullish().catch(DRIFTED_SMART_CART)
+  smartCart: EngineSmartCart.catch(DRIFTED_SMART_CART)
 });
 
 // src/schema/widgets/checkout-and-beyond/image.ts
@@ -2388,7 +2404,17 @@ var GIFT_LABELS = {
 // src/schema/widgets/checkout-and-beyond/progressBar.ts
 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(() => []),
+  /**
+   * `products` rules: each excluded product with ITS OWN variants, mirroring the bar-level
+   * excluded products. An empty `variantIds` means "the whole product", which is how the admin
+   * picker stores a whole-product selection, and a populated one means those variants.
+   */
+  products: import_zod33.z.array(
+    import_zod33.z.object({
+      productId: import_zod33.z.number().int().positive(),
+      variantIds: import_zod33.z.array(import_zod33.z.number().int().positive()).default(() => [])
+    })
+  ).default(() => []),
   tags: import_zod33.z.array(import_zod33.z.string().min(1)).default(() => []),
   type: import_zod33.z.enum(progressTierExclusionTypes)
 });
@@ -5325,13 +5351,21 @@ var giftOf = (tier) => {
     variantIds: positiveIds(product.variantIds)
   };
 };
-var RULE_LIST = { collections: "collectionIds", products: "productIds", tags: "tags" };
+var RULE_LIST = { collections: "collectionIds", products: "products", tags: "tags" };
+var exclusionProducts = (rule) => (rule.products ?? []).flatMap((entry) => {
+  const productId2 = entry.productId;
+  if (!Number.isInteger(productId2) || !productId2 || productId2 <= 0) return [];
+  const requested = entry.variantIds ?? [];
+  const variantIds = positiveIds(requested);
+  if (requested.length > 0 && variantIds.length === 0) return [];
+  return [{ productId: productId2, variantIds }];
+});
 var exclusionsOf = (tier) => {
   if (!tier.exclusionsEnabled) return void 0;
   const rules = (tier.exclusions ?? []).flatMap((rule) => {
     const parsed = CABProgressTierExclusion.safeParse({
       ...rule.type === "collections" && { collectionIds: positiveIds(rule.collectionIds) },
-      ...rule.type === "products" && { productIds: positiveIds(rule.productIds) },
+      ...rule.type === "products" && { products: exclusionProducts(rule) },
       ...rule.type === "tags" && { tags: (rule.tags ?? []).map((tag) => tag.trim()).filter(Boolean) },
       type: rule.type
     });
@@ -6728,6 +6762,23 @@ var projectPostPurchasePlanCatalog = (normalized, report) => {
   }
 };
 
+// src/server/postPurchaseUnavailableChoice.ts
+var choiceUnavailable = (reason) => Object.freeze({ level: "choice", reason });
+var configurationUnavailable = (reason) => ({
+  level: "configuration",
+  reason
+});
+var VARIANT_UNAVAILABLE = choiceUnavailable("The chosen variant is unavailable");
+var PLAN_UNAVAILABLE = choiceUnavailable("Subscription plan is unavailable");
+var CHOICE_UNAVAILABLE = choiceUnavailable("Requested purchase choice is unavailable");
+var GROUP_DEFAULT_UNAVAILABLE = choiceUnavailable("Post-purchase group default is unavailable");
+var unsupportedPreparation = ({ level, reason }) => ({
+  level,
+  reason,
+  status: "unsupported"
+});
+var publicPreparation = (preparation) => preparation.status === "unsupported" ? { reason: preparation.reason, status: "unsupported" } : preparation;
+
 // src/schema/postPurchaseSubscriptionProduct.ts
 var import_zod64 = require("zod");
 
@@ -6866,26 +6917,15 @@ var PostPurchaseSubscriptionSettings = subscription.extend({
   })
 });
 
-// src/server/postPurchaseUnavailableChoice.ts
-var VARIANT_UNAVAILABLE = "The chosen variant is unavailable";
-var PLAN_UNAVAILABLE = "Subscription plan is unavailable";
-var CHOICE_UNAVAILABLE = "Requested purchase choice is unavailable";
-var GROUP_DEFAULT_UNAVAILABLE = "Post-purchase group default is unavailable";
-var choiceLevel = /* @__PURE__ */ new Set([
-  VARIANT_UNAVAILABLE,
-  PLAN_UNAVAILABLE,
-  CHOICE_UNAVAILABLE,
-  GROUP_DEFAULT_UNAVAILABLE
-]);
-var isChoiceUnavailable = (reason) => reason !== void 0 && choiceLevel.has(reason);
-
 // src/server/postPurchaseVariantAvailable.ts
 var postPurchaseVariantAvailable = (variant2) => !(variant2.inventoryManagement && variant2.inventoryPolicy === "deny" && variant2.inventoryQuantity <= 0);
 
 // src/server/postPurchaseSubscriptionEligibility.ts
 var subscriptionUnavailable = (normalized, plan, allowCollection, quantity3) => {
   const { data, effective, original } = normalized;
-  const unavailable = "An eligible subscription plan with supported shipping and discount is required";
+  const unavailable = configurationUnavailable(
+    "An eligible subscription plan with supported shipping and discount is required"
+  );
   if (data.length !== 1 || data[0].variants.length !== 1) return unavailable;
   if (
     // Legacy STS ran whatever the product type: its trigger forced the subscription option on.
@@ -7052,9 +7092,9 @@ var projectPostPurchaseProduct = ({ data, effective, metadata, original }, repor
 
 // src/server/prepareNormalizedSubscription.ts
 var prepareNormalizedSubscription = (normalized, report, plan, quantity3, allowCollection = false) => {
-  if (!plan) return { reason: PLAN_UNAVAILABLE, status: "unsupported" };
-  const reason = subscriptionUnavailable(normalized, plan, allowCollection, quantity3);
-  if (reason) return { reason, status: "unsupported" };
+  if (!plan) return unsupportedPreparation(PLAN_UNAVAILABLE);
+  const unavailable = subscriptionUnavailable(normalized, plan, allowCollection, quantity3);
+  if (unavailable) return unsupportedPreparation(unavailable);
   const { effective } = normalized;
   const projected = projectPostPurchaseProduct(normalized, report, quantity3);
   const { discount, shipping } = PostPurchaseSubscriptionSettings.parse(effective.subscription);
@@ -7088,33 +7128,34 @@ var prepareNormalizedSubscription = (normalized, report, plan, quantity3, allowC
 // src/server/preparePostPurchaseSubscription.ts
 var preparePostPurchaseSubscription = (settings, response, report) => {
   const normalized = normalizePostPurchaseProduct(settings, response, report);
-  return prepareNormalizedSubscription(
-    normalized,
-    report,
-    projectPostPurchasePlanCatalog(normalized, report)?.plans[0]
+  return publicPreparation(
+    prepareNormalizedSubscription(normalized, report, projectPostPurchasePlanCatalog(normalized, report)?.plans[0])
   );
 };
 
 // src/server/postPurchaseProductEligibility.ts
 var oneTimeUnavailable = (normalized, allowCollection, quantity3) => {
   const { data, effective, original } = normalized;
-  if (data.length !== 1 || data[0].variants.length !== 1) return "Only one fixed product and variant are supported";
+  if (data.length !== 1 || data[0].variants.length !== 1)
+    return configurationUnavailable("Only one fixed product and variant are supported");
   if (effective.productType === "subscription" || [original, effective].some(
     (config) => !allowCollection && config.productLimit !== 1 || config.upgradeToSubscription.allow || !quantity3 && config.quantityInputs.enabled && (config.quantityInputs.minValue !== config.quantityInputs.maxValue || config.quantityInputs.defaultQuantity !== config.quantityInputs.minValue)
   ))
-    return "Only fixed one-time configuration is supported";
+    return configurationUnavailable("Only fixed one-time configuration is supported");
   const product = data[0];
   const variant2 = product.variants[0];
   if (product.productGroupVariants.length || requiresOwnSellingPlan(product) || product.sellingPlanGroups?.some((group) => group.requiresSellingPlan))
-    return "A one-time variant without product groups or a required selling plan is required";
+    return configurationUnavailable(
+      "A one-time variant without product groups or a required selling plan is required"
+    );
   if (!postPurchaseVariantAvailable(variant2)) return VARIANT_UNAVAILABLE;
   if (variant2.productId !== product.id) throw new Error("Product variant identity mismatch");
 };
 
 // src/server/preparePostPurchaseProduct.ts
 var prepareNormalizedProduct = (normalized, report, quantity3, allowCollection = false) => {
-  const reason = oneTimeUnavailable(normalized, allowCollection, quantity3);
-  if (reason) return { reason, status: "unsupported" };
+  const unavailable = oneTimeUnavailable(normalized, allowCollection, quantity3);
+  if (unavailable) return unsupportedPreparation(unavailable);
   const { effective } = normalized;
   return PreparedPostPurchaseProduct.parse({
     ...projectPostPurchaseProduct(normalized, report, quantity3),
@@ -7125,7 +7166,7 @@ var prepareNormalizedProduct = (normalized, report, quantity3, allowCollection =
     }
   });
 };
-var preparePostPurchaseProduct = (settings, response, report) => prepareNormalizedProduct(normalizePostPurchaseProduct(settings, response, report), report);
+var preparePostPurchaseProduct = (settings, response, report) => publicPreparation(prepareNormalizedProduct(normalizePostPurchaseProduct(settings, response, report), report));
 
 // src/schema/postPurchaseProductView.ts
 var import_zod73 = require("zod");
@@ -7381,7 +7422,7 @@ var postPurchaseCardSections = (widgetId, {
 var preparePostPurchaseCardSections = (widgetId, settings, response, report) => postPurchaseCardSections(widgetId, normalizePostPurchaseProduct(settings, response, report), report);
 
 // src/server/selectPostPurchaseChoice.ts
-var preferChoiceLevel = (preferred, other) => !isChoiceUnavailable(preferred) && isChoiceUnavailable(other) ? other : preferred;
+var preferChoiceLevel = (preferred, other) => preferred.level === "configuration" && other.level === "choice" ? other : preferred;
 var selectPostPurchaseChoice = (normalized, projected, requested, allowCollection, quantity3) => {
   const { data, effective } = normalized;
   const modes = [];
@@ -7396,7 +7437,7 @@ var selectPostPurchaseChoice = (normalized, projected, requested, allowCollectio
       choice: void 0,
       options: void 0,
       plan: void 0,
-      reason: preferChoiceLevel(
+      unavailable: preferChoiceLevel(
         effective.productType === "one-time" ? oneTimeReason : subscriptionReason,
         effective.productType === "one-time" ? subscriptionReason : oneTimeReason
       )
@@ -7410,7 +7451,7 @@ var selectPostPurchaseChoice = (normalized, projected, requested, allowCollectio
     choice: bound,
     options: options2,
     plan: bound ? plan : void 0,
-    reason: bound ? void 0 : CHOICE_UNAVAILABLE
+    unavailable: bound ? void 0 : CHOICE_UNAVAILABLE
   };
 };
 
@@ -7426,13 +7467,13 @@ var prepareNormalizedPostPurchaseView = (widgetId, normalized, report, choice, q
   const labels = { notAvailable: normalized.effective.language.global.notAvailable };
   const sts = quantity3?.sts === true;
   const marker = sts ? { sts: true } : {};
-  const preparation = !selected.choice ? { reason: selected.reason, status: "unsupported" } : selected.choice.mode === "subscription" ? prepareNormalizedSubscription(normalized, report, selected.plan, quantity3, allowCollection) : prepareNormalizedProduct(normalized, report, quantity3, allowCollection);
+  const preparation = !selected.choice ? unsupportedPreparation(selected.unavailable) : selected.choice.mode === "subscription" ? prepareNormalizedSubscription(normalized, report, selected.plan, quantity3, allowCollection) : prepareNormalizedProduct(normalized, report, quantity3, allowCollection);
   if (preparation.status === "unsupported") {
-    const sections2 = isChoiceUnavailable(preparation.reason) ? postPurchaseCardSections(widgetId, normalized, report, sts) : null;
+    const sections2 = preparation.level === "choice" ? postPurchaseCardSections(widgetId, normalized, report, sts) : null;
     return PostPurchaseProductView.parse({
       labels,
       planCatalog,
-      preparation,
+      preparation: publicPreparation(preparation),
       purchaseOptions,
       sections: sections2,
       ...marker
@@ -8162,7 +8203,7 @@ var preparePostPurchaseCollectionGroup = (widgetId, settings, response, member,
     view: prepared ? { ...prepared.view, groupCatalog: prepared.groupCatalog } : {
       groupCatalog: group.catalog,
       labels: { notAvailable: normalized.effective.language.global.notAvailable },
-      preparation: { reason: GROUP_DEFAULT_UNAVAILABLE, status: "unsupported" },
+      preparation: publicPreparation(unsupportedPreparation(GROUP_DEFAULT_UNAVAILABLE)),
       sections: postPurchaseCardSections(widgetId, normalized, report)
     }
   };

package/dist/server/index.mjs

@@ -1503,7 +1503,22 @@ var SmartCartTierProduct = z19.looseObject({
 });
 var SmartCartTierExclusion = z19.looseObject({
   collectionIds: z19.array(z19.coerce.number()).optional().catch(void 0),
-  productIds: z19.array(z19.coerce.number()).optional().catch(void 0),
+  /**
+   * onsite keeps each excluded product with ITS OWN variants, the same shape the bar-level
+   * `excludedProducts` uses, so a rule can exclude one variant of B without touching A.
+   * Flat parallel id lists cannot express that mapping.
+   *
+   * camelCase like every other key in this file, NOT the `product_id` / `variant_ids` the onsite
+   * payload spells: `parseShielded` runs `deepCamelCase` over the tree BEFORE any schema sees it.
+   * A snake_case key here reads as absent, every entry drops, and the converter discards the whole
+   * rule in silence — the exclusion just never reaches checkout.
+   */
+  products: z19.array(
+    z19.looseObject({
+      productId: z19.coerce.number().optional().catch(void 0),
+      variantIds: z19.array(z19.coerce.number()).optional().catch(void 0)
+    })
+  ).optional().catch(void 0),
   tags: z19.array(z19.string()).optional().catch(void 0),
   type: z19.string().optional().catch(void 0)
 });
@@ -1638,6 +1653,7 @@ var SmartCartComponent = z19.looseObject({
 var SmartCartConfig = z19.looseObject({
   components: z19.array(SmartCartComponent).optional()
 });
+var EngineSmartCart = z19.preprocess((value) => value === false ? null : value, SmartCartConfig.nullish());
 
 // src/schema/cabShopConfig.ts
 var CabActiveExperiment = z20.object({
@@ -1735,7 +1751,7 @@ var CabShopConfig = z20.object({
 });
 var CabUserConfig = z20.object({
   shop: CabShopConfig,
-  smartCart: SmartCartConfig.nullish().catch(DRIFTED_SMART_CART)
+  smartCart: EngineSmartCart.catch(DRIFTED_SMART_CART)
 });
 
 // src/schema/widgets/checkout-and-beyond/image.ts
@@ -2315,7 +2331,17 @@ var GIFT_LABELS = {
 // src/schema/widgets/checkout-and-beyond/progressBar.ts
 var CABProgressTierExclusion = z33.object({
   collectionIds: z33.array(z33.number().int().positive()).default(() => []),
-  productIds: z33.array(z33.number().int().positive()).default(() => []),
+  /**
+   * `products` rules: each excluded product with ITS OWN variants, mirroring the bar-level
+   * excluded products. An empty `variantIds` means "the whole product", which is how the admin
+   * picker stores a whole-product selection, and a populated one means those variants.
+   */
+  products: z33.array(
+    z33.object({
+      productId: z33.number().int().positive(),
+      variantIds: z33.array(z33.number().int().positive()).default(() => [])
+    })
+  ).default(() => []),
   tags: z33.array(z33.string().min(1)).default(() => []),
   type: z33.enum(progressTierExclusionTypes)
 });
@@ -5252,13 +5278,21 @@ var giftOf = (tier) => {
     variantIds: positiveIds(product.variantIds)
   };
 };
-var RULE_LIST = { collections: "collectionIds", products: "productIds", tags: "tags" };
+var RULE_LIST = { collections: "collectionIds", products: "products", tags: "tags" };
+var exclusionProducts = (rule) => (rule.products ?? []).flatMap((entry) => {
+  const productId2 = entry.productId;
+  if (!Number.isInteger(productId2) || !productId2 || productId2 <= 0) return [];
+  const requested = entry.variantIds ?? [];
+  const variantIds = positiveIds(requested);
+  if (requested.length > 0 && variantIds.length === 0) return [];
+  return [{ productId: productId2, variantIds }];
+});
 var exclusionsOf = (tier) => {
   if (!tier.exclusionsEnabled) return void 0;
   const rules = (tier.exclusions ?? []).flatMap((rule) => {
     const parsed = CABProgressTierExclusion.safeParse({
       ...rule.type === "collections" && { collectionIds: positiveIds(rule.collectionIds) },
-      ...rule.type === "products" && { productIds: positiveIds(rule.productIds) },
+      ...rule.type === "products" && { products: exclusionProducts(rule) },
       ...rule.type === "tags" && { tags: (rule.tags ?? []).map((tag) => tag.trim()).filter(Boolean) },
       type: rule.type
     });
@@ -6655,6 +6689,23 @@ var projectPostPurchasePlanCatalog = (normalized, report) => {
   }
 };
 
+// src/server/postPurchaseUnavailableChoice.ts
+var choiceUnavailable = (reason) => Object.freeze({ level: "choice", reason });
+var configurationUnavailable = (reason) => ({
+  level: "configuration",
+  reason
+});
+var VARIANT_UNAVAILABLE = choiceUnavailable("The chosen variant is unavailable");
+var PLAN_UNAVAILABLE = choiceUnavailable("Subscription plan is unavailable");
+var CHOICE_UNAVAILABLE = choiceUnavailable("Requested purchase choice is unavailable");
+var GROUP_DEFAULT_UNAVAILABLE = choiceUnavailable("Post-purchase group default is unavailable");
+var unsupportedPreparation = ({ level, reason }) => ({
+  level,
+  reason,
+  status: "unsupported"
+});
+var publicPreparation = (preparation) => preparation.status === "unsupported" ? { reason: preparation.reason, status: "unsupported" } : preparation;
+
 // src/schema/postPurchaseSubscriptionProduct.ts
 import { z as z64 } from "zod";
 
@@ -6793,26 +6844,15 @@ var PostPurchaseSubscriptionSettings = subscription.extend({
   })
 });
 
-// src/server/postPurchaseUnavailableChoice.ts
-var VARIANT_UNAVAILABLE = "The chosen variant is unavailable";
-var PLAN_UNAVAILABLE = "Subscription plan is unavailable";
-var CHOICE_UNAVAILABLE = "Requested purchase choice is unavailable";
-var GROUP_DEFAULT_UNAVAILABLE = "Post-purchase group default is unavailable";
-var choiceLevel = /* @__PURE__ */ new Set([
-  VARIANT_UNAVAILABLE,
-  PLAN_UNAVAILABLE,
-  CHOICE_UNAVAILABLE,
-  GROUP_DEFAULT_UNAVAILABLE
-]);
-var isChoiceUnavailable = (reason) => reason !== void 0 && choiceLevel.has(reason);
-
 // src/server/postPurchaseVariantAvailable.ts
 var postPurchaseVariantAvailable = (variant2) => !(variant2.inventoryManagement && variant2.inventoryPolicy === "deny" && variant2.inventoryQuantity <= 0);
 
 // src/server/postPurchaseSubscriptionEligibility.ts
 var subscriptionUnavailable = (normalized, plan, allowCollection, quantity3) => {
   const { data, effective, original } = normalized;
-  const unavailable = "An eligible subscription plan with supported shipping and discount is required";
+  const unavailable = configurationUnavailable(
+    "An eligible subscription plan with supported shipping and discount is required"
+  );
   if (data.length !== 1 || data[0].variants.length !== 1) return unavailable;
   if (
     // Legacy STS ran whatever the product type: its trigger forced the subscription option on.
@@ -6979,9 +7019,9 @@ var projectPostPurchaseProduct = ({ data, effective, metadata, original }, repor
 
 // src/server/prepareNormalizedSubscription.ts
 var prepareNormalizedSubscription = (normalized, report, plan, quantity3, allowCollection = false) => {
-  if (!plan) return { reason: PLAN_UNAVAILABLE, status: "unsupported" };
-  const reason = subscriptionUnavailable(normalized, plan, allowCollection, quantity3);
-  if (reason) return { reason, status: "unsupported" };
+  if (!plan) return unsupportedPreparation(PLAN_UNAVAILABLE);
+  const unavailable = subscriptionUnavailable(normalized, plan, allowCollection, quantity3);
+  if (unavailable) return unsupportedPreparation(unavailable);
   const { effective } = normalized;
   const projected = projectPostPurchaseProduct(normalized, report, quantity3);
   const { discount, shipping } = PostPurchaseSubscriptionSettings.parse(effective.subscription);
@@ -7015,33 +7055,34 @@ var prepareNormalizedSubscription = (normalized, report, plan, quantity3, allowC
 // src/server/preparePostPurchaseSubscription.ts
 var preparePostPurchaseSubscription = (settings, response, report) => {
   const normalized = normalizePostPurchaseProduct(settings, response, report);
-  return prepareNormalizedSubscription(
-    normalized,
-    report,
-    projectPostPurchasePlanCatalog(normalized, report)?.plans[0]
+  return publicPreparation(
+    prepareNormalizedSubscription(normalized, report, projectPostPurchasePlanCatalog(normalized, report)?.plans[0])
   );
 };
 
 // src/server/postPurchaseProductEligibility.ts
 var oneTimeUnavailable = (normalized, allowCollection, quantity3) => {
   const { data, effective, original } = normalized;
-  if (data.length !== 1 || data[0].variants.length !== 1) return "Only one fixed product and variant are supported";
+  if (data.length !== 1 || data[0].variants.length !== 1)
+    return configurationUnavailable("Only one fixed product and variant are supported");
   if (effective.productType === "subscription" || [original, effective].some(
     (config) => !allowCollection && config.productLimit !== 1 || config.upgradeToSubscription.allow || !quantity3 && config.quantityInputs.enabled && (config.quantityInputs.minValue !== config.quantityInputs.maxValue || config.quantityInputs.defaultQuantity !== config.quantityInputs.minValue)
   ))
-    return "Only fixed one-time configuration is supported";
+    return configurationUnavailable("Only fixed one-time configuration is supported");
   const product = data[0];
   const variant2 = product.variants[0];
   if (product.productGroupVariants.length || requiresOwnSellingPlan(product) || product.sellingPlanGroups?.some((group) => group.requiresSellingPlan))
-    return "A one-time variant without product groups or a required selling plan is required";
+    return configurationUnavailable(
+      "A one-time variant without product groups or a required selling plan is required"
+    );
   if (!postPurchaseVariantAvailable(variant2)) return VARIANT_UNAVAILABLE;
   if (variant2.productId !== product.id) throw new Error("Product variant identity mismatch");
 };
 
 // src/server/preparePostPurchaseProduct.ts
 var prepareNormalizedProduct = (normalized, report, quantity3, allowCollection = false) => {
-  const reason = oneTimeUnavailable(normalized, allowCollection, quantity3);
-  if (reason) return { reason, status: "unsupported" };
+  const unavailable = oneTimeUnavailable(normalized, allowCollection, quantity3);
+  if (unavailable) return unsupportedPreparation(unavailable);
   const { effective } = normalized;
   return PreparedPostPurchaseProduct.parse({
     ...projectPostPurchaseProduct(normalized, report, quantity3),
@@ -7052,7 +7093,7 @@ var prepareNormalizedProduct = (normalized, report, quantity3, allowCollection =
     }
   });
 };
-var preparePostPurchaseProduct = (settings, response, report) => prepareNormalizedProduct(normalizePostPurchaseProduct(settings, response, report), report);
+var preparePostPurchaseProduct = (settings, response, report) => publicPreparation(prepareNormalizedProduct(normalizePostPurchaseProduct(settings, response, report), report));
 
 // src/schema/postPurchaseProductView.ts
 import { z as z73 } from "zod";
@@ -7308,7 +7349,7 @@ var postPurchaseCardSections = (widgetId, {
 var preparePostPurchaseCardSections = (widgetId, settings, response, report) => postPurchaseCardSections(widgetId, normalizePostPurchaseProduct(settings, response, report), report);
 
 // src/server/selectPostPurchaseChoice.ts
-var preferChoiceLevel = (preferred, other) => !isChoiceUnavailable(preferred) && isChoiceUnavailable(other) ? other : preferred;
+var preferChoiceLevel = (preferred, other) => preferred.level === "configuration" && other.level === "choice" ? other : preferred;
 var selectPostPurchaseChoice = (normalized, projected, requested, allowCollection, quantity3) => {
   const { data, effective } = normalized;
   const modes = [];
@@ -7323,7 +7364,7 @@ var selectPostPurchaseChoice = (normalized, projected, requested, allowCollectio
       choice: void 0,
       options: void 0,
       plan: void 0,
-      reason: preferChoiceLevel(
+      unavailable: preferChoiceLevel(
         effective.productType === "one-time" ? oneTimeReason : subscriptionReason,
         effective.productType === "one-time" ? subscriptionReason : oneTimeReason
       )
@@ -7337,7 +7378,7 @@ var selectPostPurchaseChoice = (normalized, projected, requested, allowCollectio
     choice: bound,
     options: options2,
     plan: bound ? plan : void 0,
-    reason: bound ? void 0 : CHOICE_UNAVAILABLE
+    unavailable: bound ? void 0 : CHOICE_UNAVAILABLE
   };
 };
 
@@ -7353,13 +7394,13 @@ var prepareNormalizedPostPurchaseView = (widgetId, normalized, report, choice, q
   const labels = { notAvailable: normalized.effective.language.global.notAvailable };
   const sts = quantity3?.sts === true;
   const marker = sts ? { sts: true } : {};
-  const preparation = !selected.choice ? { reason: selected.reason, status: "unsupported" } : selected.choice.mode === "subscription" ? prepareNormalizedSubscription(normalized, report, selected.plan, quantity3, allowCollection) : prepareNormalizedProduct(normalized, report, quantity3, allowCollection);
+  const preparation = !selected.choice ? unsupportedPreparation(selected.unavailable) : selected.choice.mode === "subscription" ? prepareNormalizedSubscription(normalized, report, selected.plan, quantity3, allowCollection) : prepareNormalizedProduct(normalized, report, quantity3, allowCollection);
   if (preparation.status === "unsupported") {
-    const sections2 = isChoiceUnavailable(preparation.reason) ? postPurchaseCardSections(widgetId, normalized, report, sts) : null;
+    const sections2 = preparation.level === "choice" ? postPurchaseCardSections(widgetId, normalized, report, sts) : null;
     return PostPurchaseProductView.parse({
       labels,
       planCatalog,
-      preparation,
+      preparation: publicPreparation(preparation),
       purchaseOptions,
       sections: sections2,
       ...marker
@@ -8089,7 +8130,7 @@ var preparePostPurchaseCollectionGroup = (widgetId, settings, response, member,
     view: prepared ? { ...prepared.view, groupCatalog: prepared.groupCatalog } : {
       groupCatalog: group.catalog,
       labels: { notAvailable: normalized.effective.language.global.notAvailable },
-      preparation: { reason: GROUP_DEFAULT_UNAVAILABLE, status: "unsupported" },
+      preparation: publicPreparation(unsupportedPreparation(GROUP_DEFAULT_UNAVAILABLE)),
       sections: postPurchaseCardSections(widgetId, normalized, report)
     }
   };

package/dist/server/postPurchaseProductEligibility.d.ts

@@ -1,4 +1,5 @@
 import type { normalizePostPurchaseProduct } from '../server/normalizePostPurchaseProduct';
+import { type PostPurchaseUnavailable } from '../server/postPurchaseUnavailableChoice';
 import type { PostPurchaseQuantity } from '../server/readPostPurchaseQuantity';
 /** The same eligibility rule drives advertised modes and their prepared terms. */
-export declare const oneTimeUnavailable: (normalized: ReturnType<typeof normalizePostPurchaseProduct>, allowCollection: boolean, quantity?: PostPurchaseQuantity) => "The chosen variant is unavailable" | "Only one fixed product and variant are supported" | "Only fixed one-time configuration is supported" | "A one-time variant without product groups or a required selling plan is required" | undefined;
+export declare const oneTimeUnavailable: (normalized: ReturnType<typeof normalizePostPurchaseProduct>, allowCollection: boolean, quantity?: PostPurchaseQuantity) => PostPurchaseUnavailable | undefined;

package/dist/server/postPurchaseSubscriptionEligibility.d.ts

@@ -1,4 +1,5 @@
 import type { PostPurchasePlanOption } from '../schema/postPurchasePlanCatalog';
 import type { normalizePostPurchaseProduct } from '../server/normalizePostPurchaseProduct';
+import { type PostPurchaseUnavailable } from '../server/postPurchaseUnavailableChoice';
 import type { PostPurchaseQuantity } from '../server/readPostPurchaseQuantity';
-export declare const subscriptionUnavailable: (normalized: ReturnType<typeof normalizePostPurchaseProduct>, plan: PostPurchasePlanOption | undefined, allowCollection: boolean, quantity?: PostPurchaseQuantity) => "The chosen variant is unavailable" | "Subscription plan is unavailable" | "An eligible subscription plan with supported shipping and discount is required" | undefined;
+export declare const subscriptionUnavailable: (normalized: ReturnType<typeof normalizePostPurchaseProduct>, plan: PostPurchasePlanOption | undefined, allowCollection: boolean, quantity?: PostPurchaseQuantity) => PostPurchaseUnavailable | undefined;

package/dist/server/postPurchaseUnavailableChoice.d.ts

@@ -1,12 +1,45 @@
+import type { PostPurchasePreparation } from '../schema/postPurchaseProduct';
 /**
- * Choice-level unavailability: the widget is readable and its card converts, but the choice the buyer is looking
- * at cannot be bought right now — its variant is sold out, its plan is gone, the requested mode is not offered,
- * or a group has no available default. Like cab-checkout's sold-out card, such a product still carries its tree
- * (values resolve blank; Pay shows `notAvailable`). Every other reason is configuration-level and keeps
- * `sections: null`.
+ * Why a post-purchase card cannot be bought, and at which level. Choice-level: the widget is readable and its
+ * card converts, but the choice the buyer is looking at cannot be bought right now — its variant is sold out,
+ * its plan is gone, the requested mode is not offered, or a group has no available default. Like cab-checkout's
+ * sold-out card, such a product still carries its tree (values resolve blank; Pay shows `notAvailable`).
+ * Configuration-level: the widget itself is unsupported, and the view keeps `sections: null`.
+ *
+ * The eligibility helpers return the level with the reason, so the tree-or-`null` decision reads `level`
+ * instead of matching reason text against a list — rewording a reason can no longer move it between levels.
  */
-export declare const VARIANT_UNAVAILABLE = "The chosen variant is unavailable";
-export declare const PLAN_UNAVAILABLE = "Subscription plan is unavailable";
-export declare const CHOICE_UNAVAILABLE = "Requested purchase choice is unavailable";
-export declare const GROUP_DEFAULT_UNAVAILABLE = "Post-purchase group default is unavailable";
-export declare const isChoiceUnavailable: (reason: string | undefined) => boolean;
+export type PostPurchaseUnavailable = Readonly<{
+    level: 'choice' | 'configuration';
+    reason: string;
+}>;
+/** An unsupported preparation that still carries its level, for the server's own tree-or-`null` decision. */
+export type LeveledPostPurchasePreparation = Exclude<PostPurchasePreparation, {
+    status: 'unsupported';
+}> | (PostPurchaseUnavailable & {
+    status: 'unsupported';
+});
+export declare const configurationUnavailable: (reason: string) => PostPurchaseUnavailable;
+export declare const VARIANT_UNAVAILABLE: Readonly<{
+    level: "choice" | "configuration";
+    reason: string;
+}>;
+export declare const PLAN_UNAVAILABLE: Readonly<{
+    level: "choice" | "configuration";
+    reason: string;
+}>;
+export declare const CHOICE_UNAVAILABLE: Readonly<{
+    level: "choice" | "configuration";
+    reason: string;
+}>;
+export declare const GROUP_DEFAULT_UNAVAILABLE: Readonly<{
+    level: "choice" | "configuration";
+    reason: string;
+}>;
+export declare const unsupportedPreparation: ({ level, reason }: PostPurchaseUnavailable) => {
+    level: "choice" | "configuration";
+    reason: string;
+    status: "unsupported";
+};
+/** The public preparation contract carries the reason only; the level is a server-side routing fact. */
+export declare const publicPreparation: (preparation: LeveledPostPurchasePreparation) => PostPurchasePreparation;