@rebuy/rebuy 3.61.0 → 3.62.0

package/dist/index.cjs

@@ -121,6 +121,7 @@ __export(src_exports, {
   DiscountSource: () => DiscountSource,
   DiscountType: () => DiscountType,
   EditorMode: () => EditorMode,
+  EngineSmartCart: () => EngineSmartCart,
   EventCalculationSchema: () => EventCalculationSchema,
   ExitPolicySchema: () => ExitPolicySchema,
   FinishedPurchaseSchema: () => FinishedPurchaseSchema,
@@ -1378,6 +1379,7 @@ var SmartCartComponent = import_zod.z.looseObject({
 var SmartCartConfig = import_zod.z.looseObject({
   components: import_zod.z.array(SmartCartComponent).optional()
 });
+var EngineSmartCart = import_zod.z.preprocess((value) => value === false ? null : value, SmartCartConfig.nullish());
 
 // src/schema/cabShopConfig.ts
 var CabActiveExperiment = import_zod2.z.object({
@@ -1475,7 +1477,7 @@ var CabShopConfig = import_zod2.z.object({
 });
 var CabUserConfig = import_zod2.z.object({
   shop: CabShopConfig,
-  smartCart: SmartCartConfig.nullish().catch(DRIFTED_SMART_CART)
+  smartCart: EngineSmartCart.catch(DRIFTED_SMART_CART)
 });
 
 // src/schema/metadata.ts
@@ -5263,10 +5265,14 @@ var import_zod93 = require("zod");
 var UserConfig = import_zod93.z.object({
   shop: ShopConfig,
   /**
-   * `.catch(undefined)` is the safety bar: smart-cart shape drift can NEVER fail `fetchUserConfig`,
-   * which resolves the apiKey for every offers/monetize/analytics/gift request.
+   * Parsed like `CabUserConfig.smartCart`: the engine's `false` reads as `null` ({@link EngineSmartCart}), a
+   * drifted component loses only its own settings (`SmartCartComponent.settings` catches per component), and
+   * `.catch(undefined)` is the last safety bar so a wholly unreadable config can never fail the parse that
+   * resolves the shop's apiKey. It lands on `undefined`, not the `DRIFTED_SMART_CART` sentinel: no drift
+   * reporter reads this schema (the server parses `CabUserConfig`), and that sentinel's identity is not
+   * exported from `./schema`, so a consumer could not tell it apart from an empty config anyway.
    */
-  smartCart: SmartCartConfig.nullish().catch(void 0),
+  smartCart: EngineSmartCart.catch(void 0),
   smartFlows: import_zod93.z.array(import_zod93.z.unknown())
 });
 

package/dist/index.mjs

@@ -896,6 +896,7 @@ var SmartCartComponent = z.looseObject({
 var SmartCartConfig = z.looseObject({
   components: z.array(SmartCartComponent).optional()
 });
+var EngineSmartCart = z.preprocess((value) => value === false ? null : value, SmartCartConfig.nullish());
 
 // src/schema/cabShopConfig.ts
 var CabActiveExperiment = z2.object({
@@ -993,7 +994,7 @@ var CabShopConfig = z2.object({
 });
 var CabUserConfig = z2.object({
   shop: CabShopConfig,
-  smartCart: SmartCartConfig.nullish().catch(DRIFTED_SMART_CART)
+  smartCart: EngineSmartCart.catch(DRIFTED_SMART_CART)
 });
 
 // src/schema/metadata.ts
@@ -4781,10 +4782,14 @@ import { z as z93 } from "zod";
 var UserConfig = z93.object({
   shop: ShopConfig,
   /**
-   * `.catch(undefined)` is the safety bar: smart-cart shape drift can NEVER fail `fetchUserConfig`,
-   * which resolves the apiKey for every offers/monetize/analytics/gift request.
+   * Parsed like `CabUserConfig.smartCart`: the engine's `false` reads as `null` ({@link EngineSmartCart}), a
+   * drifted component loses only its own settings (`SmartCartComponent.settings` catches per component), and
+   * `.catch(undefined)` is the last safety bar so a wholly unreadable config can never fail the parse that
+   * resolves the shop's apiKey. It lands on `undefined`, not the `DRIFTED_SMART_CART` sentinel: no drift
+   * reporter reads this schema (the server parses `CabUserConfig`), and that sentinel's identity is not
+   * exported from `./schema`, so a consumer could not tell it apart from an empty config anyway.
    */
-  smartCart: SmartCartConfig.nullish().catch(void 0),
+  smartCart: EngineSmartCart.catch(void 0),
   smartFlows: z93.array(z93.unknown())
 });
 
@@ -6778,6 +6783,7 @@ export {
   DiscountSource,
   DiscountType,
   EditorMode,
+  EngineSmartCart,
   EventCalculationSchema,
   ExitPolicySchema,
   FinishedPurchaseSchema,

package/dist/schema/cabShopConfig.d.ts

@@ -62,8 +62,9 @@ export type CabShopConfig = z.infer<typeof CabShopConfig>;
  *
  * The catch lands on the {@link DRIFTED_SMART_CART} identity sentinel (no components ⇒ no bars), not
  * `undefined`, so the server's progress-bar resolution can tell a drifted config from a shop with no smart
- * cart (`null`/absent stay `null`/`undefined`) and emit a `shopConfig` drift (REB-25139: this catch used to
- * drop every progress bar for the shop silently).
+ * cart (`null`/absent stay `null`/`undefined`, and the engine's `false` reads as `null` via
+ * {@link EngineSmartCart}) and emit a `shopConfig` drift (REB-25139: this catch used to drop every progress
+ * bar for the shop silently; REB-25187: `false` used to land on the sentinel and report a false drift).
  */
 export declare const CabUserConfig: z.ZodObject<{
     shop: z.ZodObject<{
@@ -98,7 +99,7 @@ export declare const CabUserConfig: z.ZodObject<{
         shopId: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
         shopName: z.ZodCatch<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
     }, z.core.$strip>;
-    smartCart: z.ZodCatch<z.ZodOptional<z.ZodNullable<z.ZodObject<{
+    smartCart: z.ZodCatch<z.ZodPreprocess<z.ZodOptional<z.ZodNullable<z.ZodObject<{
         components: z.ZodOptional<z.ZodArray<z.ZodObject<{
             settings: z.ZodCatch<z.ZodPreprocess<z.ZodOptional<z.ZodObject<{
                 bars: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -172,6 +173,6 @@ export declare const CabUserConfig: z.ZodObject<{
             }, z.core.$loose>>>>;
             type: z.ZodOptional<z.ZodString>;
         }, z.core.$loose>>>;
-    }, z.core.$loose>>>>;
+    }, z.core.$loose>>>>>;
 }, z.core.$strip>;
 export type CabUserConfig = z.infer<typeof CabUserConfig>;

package/dist/schema/smartCart.d.ts

@@ -245,7 +245,7 @@ export declare const SmartCartComponent: z.ZodObject<{
  * The subset of the shop's smart-cart config the checkout extension reads: the
  * `tiered_progress_bar` component(s) and their bars/tiers. The rest of the onsite
  * smart-cart config (buy-more-save-more, custom templates/CSS, callbacks) is out of
- * scope — `looseObject` preserves-but-ignores it. Parsed under `UserConfig.smartCart`
+ * scope — `looseObject` preserves-but-ignores it. Parsed via {@link EngineSmartCart} under `UserConfig.smartCart`
  * (`.catch(undefined)`) and `CabUserConfig.smartCart` (`.catch` to a drift sentinel) so a shape
  * drift here can NEVER break apiKey resolution for offers / monetize / analytics / gift validation.
  */
@@ -324,6 +324,88 @@ export declare const SmartCartConfig: z.ZodObject<{
         type: z.ZodOptional<z.ZodString>;
     }, z.core.$loose>>>;
 }, z.core.$loose>;
+/**
+ * The `smartCart` field of `/api/v1/user/config` as the engine actually sends it. A shop with no enabled
+ * Smart Cart arrives as `smart_cart: false` (the engine's "none" vocabulary, like `null`/absent), so `false`
+ * reads as `null` before the object schema sees it: no smart cart, no bars, and no drift. Only `false` — a
+ * `true`, a string or a number is a genuine retype and falls through to the reader's own `.catch`.
+ * `UserConfig` and `CabUserConfig` both parse through this, each adding its own config-level `.catch`.
+ */
+export declare const EngineSmartCart: z.ZodPreprocess<z.ZodOptional<z.ZodNullable<z.ZodObject<{
+    components: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        settings: z.ZodCatch<z.ZodPreprocess<z.ZodOptional<z.ZodObject<{
+            bars: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                countryCodes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                excludeDiscountInSubtotal: z.ZodOptional<z.ZodBoolean>;
+                excludedProducts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    variantIds: z.ZodOptional<z.ZodArray<z.ZodCoercedNumber<unknown>>>;
+                }, z.core.$loose>>>;
+                freeShippingOnSubscription: z.ZodOptional<z.ZodBoolean>;
+                geolocationEnabled: z.ZodOptional<z.ZodBoolean>;
+                id: z.ZodOptional<z.ZodString>;
+                language: z.ZodPreprocess<z.ZodOptional<z.ZodObject<{
+                    freeShippingReached: z.ZodOptional<z.ZodString>;
+                    freeShippingRemaining: z.ZodOptional<z.ZodString>;
+                    giftAreaTitle: z.ZodOptional<z.ZodString>;
+                }, z.core.$loose>>>;
+                name: z.ZodOptional<z.ZodString>;
+                tiers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    allProducts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        handle: z.ZodOptional<z.ZodString>;
+                        id: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+                        productId: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+                        title: z.ZodOptional<z.ZodString>;
+                        variantIds: z.ZodOptional<z.ZodArray<z.ZodCoercedNumber<unknown>>>;
+                    }, z.core.$loose>>>;
+                    customTierLabel: z.ZodOptional<z.ZodBoolean>;
+                    customTierLabelText: z.ZodOptional<z.ZodString>;
+                    decorativeAmountReachedLabel: z.ZodOptional<z.ZodBoolean>;
+                    decorativeAmountReachedLabelText: z.ZodOptional<z.ZodString>;
+                    decorativeAmountRemainingLabel: z.ZodOptional<z.ZodBoolean>;
+                    decorativeAmountRemainingLabelText: z.ZodOptional<z.ZodString>;
+                    discountAmountFromTotal: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+                    discountAmountReachedLabel: z.ZodOptional<z.ZodBoolean>;
+                    discountAmountReachedLabelText: z.ZodOptional<z.ZodString>;
+                    discountAmountRemainingLabel: z.ZodOptional<z.ZodBoolean>;
+                    discountAmountRemainingLabelText: z.ZodOptional<z.ZodString>;
+                    discountType: z.ZodOptional<z.ZodString>;
+                    exclusions: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        collectionIds: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodCoercedNumber<unknown>>>>;
+                        products: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            productId: z.ZodCatch<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
+                            variantIds: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodCoercedNumber<unknown>>>>;
+                        }, z.core.$loose>>>>;
+                        tags: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+                        type: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+                    }, z.core.$loose>>>>;
+                    exclusionsEnabled: z.ZodCatch<z.ZodOptional<z.ZodBoolean>>;
+                    filterOosVariants: z.ZodOptional<z.ZodBoolean>;
+                    id: z.ZodOptional<z.ZodString>;
+                    minimum: z.ZodPreprocess<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
+                    presentmentCurrencies: z.ZodPreprocess<z.ZodOptional<z.ZodObject<{
+                        enabled: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$loose>>>;
+                    productAmountReachedLabel: z.ZodOptional<z.ZodBoolean>;
+                    productAmountReachedLabelText: z.ZodOptional<z.ZodString>;
+                    productAmountRemainingLabel: z.ZodOptional<z.ZodBoolean>;
+                    productAmountRemainingLabelText: z.ZodOptional<z.ZodString>;
+                    products: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        handle: z.ZodOptional<z.ZodString>;
+                        id: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+                        productId: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+                        title: z.ZodOptional<z.ZodString>;
+                        variantIds: z.ZodOptional<z.ZodArray<z.ZodCoercedNumber<unknown>>>;
+                    }, z.core.$loose>>>;
+                    productTierElementSize: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+                    productTierImage: z.ZodCatch<z.ZodOptional<z.ZodBoolean>>;
+                    type: z.ZodOptional<z.ZodString>;
+                    unlockConditionType: z.ZodOptional<z.ZodString>;
+                }, z.core.$loose>>>;
+            }, z.core.$loose>>>;
+        }, z.core.$loose>>>>;
+        type: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>>;
+}, z.core.$loose>>>>;
 export type SmartCartBar = z.infer<typeof SmartCartBar>;
 export type SmartCartConfig = z.infer<typeof SmartCartConfig>;
 export type SmartCartTier = z.infer<typeof SmartCartTier>;

package/dist/schema/user-config.cjs

@@ -277,14 +277,19 @@ var SmartCartComponent = import_zod2.z.looseObject({
 var SmartCartConfig = import_zod2.z.looseObject({
   components: import_zod2.z.array(SmartCartComponent).optional()
 });
+var EngineSmartCart = import_zod2.z.preprocess((value) => value === false ? null : value, SmartCartConfig.nullish());
 
 // src/schema/userConfig.ts
 var UserConfig = import_zod3.z.object({
   shop: ShopConfig,
   /**
-   * `.catch(undefined)` is the safety bar: smart-cart shape drift can NEVER fail `fetchUserConfig`,
-   * which resolves the apiKey for every offers/monetize/analytics/gift request.
+   * Parsed like `CabUserConfig.smartCart`: the engine's `false` reads as `null` ({@link EngineSmartCart}), a
+   * drifted component loses only its own settings (`SmartCartComponent.settings` catches per component), and
+   * `.catch(undefined)` is the last safety bar so a wholly unreadable config can never fail the parse that
+   * resolves the shop's apiKey. It lands on `undefined`, not the `DRIFTED_SMART_CART` sentinel: no drift
+   * reporter reads this schema (the server parses `CabUserConfig`), and that sentinel's identity is not
+   * exported from `./schema`, so a consumer could not tell it apart from an empty config anyway.
    */
-  smartCart: SmartCartConfig.nullish().catch(void 0),
+  smartCart: EngineSmartCart.catch(void 0),
   smartFlows: import_zod3.z.array(import_zod3.z.unknown())
 });

package/dist/schema/user-config.mjs

@@ -253,15 +253,20 @@ var SmartCartComponent = z2.looseObject({
 var SmartCartConfig = z2.looseObject({
   components: z2.array(SmartCartComponent).optional()
 });
+var EngineSmartCart = z2.preprocess((value) => value === false ? null : value, SmartCartConfig.nullish());
 
 // src/schema/userConfig.ts
 var UserConfig = z3.object({
   shop: ShopConfig,
   /**
-   * `.catch(undefined)` is the safety bar: smart-cart shape drift can NEVER fail `fetchUserConfig`,
-   * which resolves the apiKey for every offers/monetize/analytics/gift request.
+   * Parsed like `CabUserConfig.smartCart`: the engine's `false` reads as `null` ({@link EngineSmartCart}), a
+   * drifted component loses only its own settings (`SmartCartComponent.settings` catches per component), and
+   * `.catch(undefined)` is the last safety bar so a wholly unreadable config can never fail the parse that
+   * resolves the shop's apiKey. It lands on `undefined`, not the `DRIFTED_SMART_CART` sentinel: no drift
+   * reporter reads this schema (the server parses `CabUserConfig`), and that sentinel's identity is not
+   * exported from `./schema`, so a consumer could not tell it apart from an empty config anyway.
    */
-  smartCart: SmartCartConfig.nullish().catch(void 0),
+  smartCart: EngineSmartCart.catch(void 0),
   smartFlows: z3.array(z3.unknown())
 });
 export {

package/dist/schema/userConfig.d.ts

@@ -78,7 +78,7 @@ export declare const UserConfig: z.ZodObject<{
         storefrontAccessToken: z.ZodNullable<z.ZodString>;
         useRebuyIcons: z.ZodBoolean;
     }, z.core.$strip>;
-    smartCart: z.ZodCatch<z.ZodOptional<z.ZodNullable<z.ZodObject<{
+    smartCart: z.ZodCatch<z.ZodPreprocess<z.ZodOptional<z.ZodNullable<z.ZodObject<{
         components: z.ZodOptional<z.ZodArray<z.ZodObject<{
             settings: z.ZodCatch<z.ZodPreprocess<z.ZodOptional<z.ZodObject<{
                 bars: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -152,7 +152,7 @@ export declare const UserConfig: z.ZodObject<{
             }, z.core.$loose>>>>;
             type: z.ZodOptional<z.ZodString>;
         }, z.core.$loose>>>;
-    }, z.core.$loose>>>>;
+    }, z.core.$loose>>>>>;
     smartFlows: z.ZodArray<z.ZodUnknown>;
 }, z.core.$strip>;
 export type UserConfig = z.infer<typeof UserConfig>;

package/dist/server/index.cjs

@@ -1726,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({
@@ -1823,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
@@ -6761,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");
 
@@ -6899,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.
@@ -7085,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);
@@ -7121,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),
@@ -7158,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");
@@ -7414,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 = [];
@@ -7429,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
       )
@@ -7443,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
   };
 };
 
@@ -7459,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
@@ -8195,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

@@ -1653,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({
@@ -1750,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
@@ -6688,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";
 
@@ -6826,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.
@@ -7012,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);
@@ -7048,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),
@@ -7085,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";
@@ -7341,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 = [];
@@ -7356,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
       )
@@ -7370,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
   };
 };
 
@@ -7386,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
@@ -8122,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;

package/dist/server/prepareNormalizedSubscription.d.ts

@@ -1,6 +1,6 @@
 import type { PostPurchasePlanOption } from '../schema/postPurchasePlanCatalog';
-import { type PostPurchasePreparation } from '../schema/postPurchaseProduct';
 import type { normalizePostPurchaseProduct } from '../server/normalizePostPurchaseProduct';
+import { type LeveledPostPurchasePreparation } from '../server/postPurchaseUnavailableChoice';
 import type { PostPurchaseQuantity } from '../server/readPostPurchaseQuantity';
 import type { Reporter } from '../server/shared';
 /**
@@ -8,4 +8,4 @@ import type { Reporter } from '../server/shared';
  * unreadable-review drift. A switch to subscription (STS) charges no initial shipping, only the recurring
  * shipping (legacy `useSubscriptionPurchaseOptions`, L112/L122).
  */
-export declare const prepareNormalizedSubscription: (normalized: ReturnType<typeof normalizePostPurchaseProduct>, report: Reporter | undefined, plan: PostPurchasePlanOption | undefined, quantity?: PostPurchaseQuantity, allowCollection?: boolean) => PostPurchasePreparation;
+export declare const prepareNormalizedSubscription: (normalized: ReturnType<typeof normalizePostPurchaseProduct>, report: Reporter | undefined, plan: PostPurchasePlanOption | undefined, quantity?: PostPurchaseQuantity, allowCollection?: boolean) => LeveledPostPurchasePreparation;

package/dist/server/preparePostPurchaseCollectionGroup.d.ts

@@ -647,6 +647,147 @@ export declare const preparePostPurchaseCollectionGroup: (widgetId: number, sett
             notAvailable: string;
         };
         preparation: {
+            display: {
+                discountedFrom: "price" | "compare_at_price";
+                language: {
+                    description: string;
+                    descriptionEnabled: boolean;
+                };
+                primaryImage: {
+                    description: string;
+                    source: string;
+                };
+                productOptions: {
+                    showShipping: boolean;
+                    showSubtotal: boolean;
+                    showTaxes: boolean;
+                    showTotal: boolean;
+                    showVariantSelectors: boolean;
+                    showDeclineAll?: "none" | "both" | "above" | "below" | undefined;
+                };
+                responseDescription: string;
+                reviews: {
+                    color: string;
+                    rating: number;
+                    reviewCount: number;
+                    reviewsPlural: string;
+                    reviewsSingular: string;
+                    size: "small" | "large" | "medium";
+                    strokeColor: string;
+                    strokeWidth: number;
+                } | null;
+                shouldShowSavingText: boolean;
+                descriptionDocument?: {
+                    attrs: {
+                        blockSpacing?: "none" | "base" | "extraTight" | "tight" | "loose" | "extraLoose" | undefined;
+                    };
+                    content: never[] | {
+                        attrs: {
+                            textAlign?: "start" | "center" | "end" | undefined;
+                        };
+                        content: never[] | {
+                            text: string;
+                            type: "text";
+                            marks?: never[] | ({
+                                type: "bold";
+                            } | {
+                                type: "italic";
+                            } | {
+                                attrs: {
+                                    class: string | null;
+                                    href: string;
+                                    rel: string;
+                                    target: string;
+                                };
+                                type: "link";
+                            } | {
+                                type: "strike";
+                            } | {
+                                attrs: {
+                                    color: "success" | "warning" | "critical" | "base" | "decorative" | "subdued" | "accent";
+                                    fontSize: "small" | "base" | "large" | "medium" | "extraSmall" | "extraLarge" | "heading";
+                                };
+                                type: "textStyle";
+                            })[] | undefined;
+                        }[];
+                        type: "paragraph";
+                    }[];
+                    type: "doc";
+                } | undefined;
+                gallery?: {
+                    images: {
+                        description: string;
+                        id: number;
+                        source: string;
+                        thumbnail: string;
+                    }[];
+                    hasMultiple?: boolean | undefined;
+                    selectedImageId?: number | undefined;
+                } | undefined;
+            };
+            labels: {
+                declineAll: string;
+                free: string;
+                notAvailable: string;
+                payNow: string;
+                quantity: string;
+                recurringShipping: string;
+                recurringSubtotal: string;
+                save: string;
+                shipping: string;
+                subtotal: string;
+                taxes: string;
+                total: string;
+            };
+            product: {
+                title: string;
+                id: number;
+                variant: {
+                    title: string;
+                    compareAtPrice: string | null;
+                    id: number;
+                    price: string;
+                };
+                image?: {
+                    src: string;
+                } | null | undefined;
+                description?: string | null | undefined;
+            };
+            selection: {
+                productId: number;
+                quantity: number;
+                variantId: number;
+                sellingPlanId?: number | undefined;
+            };
+            status: "prepared";
+            terms: {
+                discount: {
+                    amount: number;
+                    title: string;
+                    type: "none" | "fixed_amount" | "percentage";
+                };
+                shipping: {
+                    amount: number;
+                    title: string;
+                    type: "fixed_amount" | "free";
+                };
+                subscription?: {
+                    initialShippingPrice: number;
+                    intervalLabel: string;
+                    name: string;
+                    recurringShippingPrice: number;
+                    shippingOption: {
+                        presentmentTitle: string;
+                        title: string;
+                    };
+                    adjustment?: {
+                        amount: number;
+                        type: "price" | "fixed_amount" | "percentage";
+                    } | undefined;
+                    sts?: true | undefined;
+                } | undefined;
+            };
+        } | {
             reason: string;
             status: "unsupported";
         };

package/dist/server/preparePostPurchaseProduct.d.ts

@@ -1,8 +1,9 @@
 import { type PostPurchasePreparation } from '../schema/postPurchaseProduct';
 import { normalizePostPurchaseProduct } from '../server/normalizePostPurchaseProduct';
+import { type LeveledPostPurchasePreparation } from '../server/postPurchaseUnavailableChoice';
 import type { PostPurchaseQuantity } from '../server/readPostPurchaseQuantity';
 import type { Reporter } from '../server/shared';
 /** The one-time sibling of `prepareNormalizedSubscription`; `report` receives unreadable-review drift. */
-export declare const prepareNormalizedProduct: (normalized: ReturnType<typeof normalizePostPurchaseProduct>, report?: Reporter, quantity?: PostPurchaseQuantity, allowCollection?: boolean) => PostPurchasePreparation;
+export declare const prepareNormalizedProduct: (normalized: ReturnType<typeof normalizePostPurchaseProduct>, report?: Reporter, quantity?: PostPurchaseQuantity, allowCollection?: boolean) => LeveledPostPurchasePreparation;
 /** Pure preparation only: the authenticated caller owns selected-entry binding and session expiry. */
 export declare const preparePostPurchaseProduct: (settings: unknown, response: unknown, report?: Reporter) => PostPurchasePreparation;

package/dist/server/preparePostPurchaseView.d.ts

@@ -5,7 +5,7 @@ import type { PostPurchaseQuantity } from '../server/readPostPurchaseQuantity';
 import type { Reporter } from '../server/shared';
 /**
  * Convert from the same effective settings snapshot; no product values enter the section tree. A choice-level
- * unavailable product keeps its tree (`isChoiceUnavailable`); a configuration-level one answers `sections: null`.
+ * unavailable product keeps its tree (its `level` is `choice`); a configuration-level one answers `sections: null`.
  */
 export declare const prepareNormalizedPostPurchaseView: (widgetId: number, normalized: ReturnType<typeof normalizePostPurchaseProduct>, report?: Reporter, choice?: PostPurchaseChoice, quantity?: PostPurchaseQuantity, allowCollection?: boolean) => PostPurchaseProductView;
 export declare const preparePostPurchaseView: (widgetId: number, settings: unknown, response: unknown, report?: Reporter, choice?: PostPurchaseChoice) => PostPurchaseProductView;

package/dist/server/selectPostPurchaseChoice.d.ts

@@ -10,7 +10,10 @@ export declare const selectPostPurchaseChoice: (normalized: ReturnType<typeof no
     choice: undefined;
     options: undefined;
     plan: undefined;
-    reason: string;
+    unavailable: Readonly<{
+        level: "choice" | "configuration";
+        reason: string;
+    }>;
 } | {
     choice: {
         mode: "one-time";
@@ -39,5 +42,8 @@ export declare const selectPostPurchaseChoice: (normalized: ReturnType<typeof no
         discountPercentage?: number | undefined;
         intervalFrequency?: string | undefined;
     } | undefined;
-    reason: string | undefined;
+    unavailable: Readonly<{
+        level: "choice" | "configuration";
+        reason: string;
+    }> | undefined;
 };

package/dist/server/shared.d.ts

@@ -11,12 +11,12 @@ export declare const REBUY_ENGINE_HOST = "rebuyengine.com";
  * {@link UpstreamError} on a non-2xx response so orchestrators can interpret the status.
  *
  * Defaults to GET with `params`/`search` as the query string. `headers` apply regardless of method —
- * implementations must not gate them behind a `method === 'POST'` branch. Note the only current library
- * caller sending `headers` is the analytics POST ingest (REB-21688 moved market context off the
- * REB-21102 headers onto engine params, retiring the GET+headers case and the test that witnessed it),
- * so a POST-gated implementation would pass every test in this repo today; the invariant stands so a
- * future GET caller's headers can't silently drop. Pass `method: 'POST'` with `body` (JSON body) for
- * write-style calls like analytics ingest.
+ * implementations must not gate them behind a `method === 'POST'` branch. Both current library callers
+ * sending `headers` are POSTs: the analytics ingest and B2B availability, which forwards the buyer's session
+ * token as `Authorization` (REB-21688 moved market context off the REB-21102 headers onto engine params,
+ * retiring the GET+headers case and the test that witnessed it). So a POST-gated implementation would pass
+ * every test in this repo today; the invariant stands so a future GET caller's headers can't silently drop.
+ * Pass `method: 'POST'` with `body` (JSON body) for write-style calls like analytics ingest.
  */
 export type UpstreamFetch = (path: string, params: Record<string, string>, options?: {
     body?: unknown;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rebuy/rebuy",
-    "version": "3.61.0",
+    "version": "3.62.0",
     "description": "Shared zod schemas, legacy-to-CAB widget transforms, and server orchestrators for Rebuy's Shopify consumers (rebuy-api, admin-nextjs, rebuy-shopify-extensions)",
     "license": "MIT",
     "author": "Rebuy, Inc.",
@@ -136,7 +136,7 @@
         "build:watch": "npm run clean && npm run build:types && node esbuild.config.mjs --watch",
         "check:dist": "node scripts/verify-dist.mjs",
         "check:node": "node scripts/assert-node-supported.mjs",
-        "check-types": "tsc --noEmit",
+        "check-types": "tsc --noEmit && tsc -p tsconfig.renderer.json",
         "clean": "rm -rf dist",
         "deploy": "npm run build && npx semantic-release --debug --no-ci",
         "deploy:dryrun": "npm run deploy -- --dry-run",