@rebuy/rebuy 3.56.1 → 3.56.3

package/dist/index.cjs

@@ -206,6 +206,7 @@ __export(src_exports, {
   PostPurchaseOfferEligibilityContext: () => PostPurchaseOfferEligibilityContext,
   PostPurchaseOfferPresentation: () => PostPurchaseOfferPresentation,
   PostPurchaseOfferSkipReason: () => PostPurchaseOfferSkipReason,
+  PostPurchaseOfferUnavailableReason: () => PostPurchaseOfferUnavailableReason,
   PostPurchaseOptions: () => PostPurchaseOptions,
   PostPurchaseOrderAttributes: () => PostPurchaseOrderAttributes,
   PostPurchaseOrderIdSchema: () => PostPurchaseOrderIdSchema,
@@ -2769,6 +2770,8 @@ var Product2 = ProductBase.extend({
   metafields: import_zod19.z.unknown().optional(),
   options: import_zod19.z.unknown().optional(),
   productGroupVariants: import_zod19.z.array(import_zod19.z.unknown()).default([]),
+  // REB-25048: the v2 data source flags a subscription-only product here and sends no selling plan groups
+  requiresSellingPlan: import_zod19.z.boolean().nullish(),
   selectedVariant: import_zod19.z.unknown().optional(),
   sellingPlanGroups: import_zod19.z.array(
     OfferProduct.shape.sellingPlanGroups.unwrap().element.extend({
@@ -4790,6 +4793,12 @@ var OfferPreparationResponseSchema = import_zod77.z.object({
 var import_zod78 = require("zod");
 var selection2 = PreparedPostPurchaseProduct.shape.selection;
 var PostPurchaseOfferSkipReason = import_zod78.z.enum(["empty", "no-eligible-subscription"]);
+var PostPurchaseOfferUnavailableReason = import_zod78.z.enum([
+  "catalog-unreadable",
+  "context-unreadable",
+  "eligible-sts",
+  "settings-unreadable"
+]);
 var PostPurchaseOfferEligibilityContext = import_zod78.z.object({
   excludedProductIds: PostPurchaseExcludedProductIds,
   originalLineItems: import_zod78.z.array(selection2.pick({ productId: true, sellingPlanId: true, variantId: true }))
@@ -4810,7 +4819,8 @@ var PostPurchaseOfferEligibility = import_zod78.z.discriminatedUnion("status", [
     status: import_zod78.z.literal("retain")
   }),
   import_zod78.z.object({ reason: PostPurchaseOfferSkipReason, status: import_zod78.z.literal("skip") }),
-  import_zod78.z.object({ reason: import_zod78.z.literal("eligible-sts").optional(), status: import_zod78.z.literal("unavailable") })
+  /** The classifier always names a reason; it stays optional so a reasonless answer from before still parses. */
+  import_zod78.z.object({ reason: PostPurchaseOfferUnavailableReason.optional(), status: import_zod78.z.literal("unavailable") })
 ]);
 
 // src/schema/postPurchaseOfferPresentation.ts

package/dist/index.mjs

@@ -2290,6 +2290,8 @@ var Product2 = ProductBase.extend({
   metafields: z19.unknown().optional(),
   options: z19.unknown().optional(),
   productGroupVariants: z19.array(z19.unknown()).default([]),
+  // REB-25048: the v2 data source flags a subscription-only product here and sends no selling plan groups
+  requiresSellingPlan: z19.boolean().nullish(),
   selectedVariant: z19.unknown().optional(),
   sellingPlanGroups: z19.array(
     OfferProduct.shape.sellingPlanGroups.unwrap().element.extend({
@@ -4311,6 +4313,12 @@ var OfferPreparationResponseSchema = z77.object({
 import { z as z78 } from "zod";
 var selection2 = PreparedPostPurchaseProduct.shape.selection;
 var PostPurchaseOfferSkipReason = z78.enum(["empty", "no-eligible-subscription"]);
+var PostPurchaseOfferUnavailableReason = z78.enum([
+  "catalog-unreadable",
+  "context-unreadable",
+  "eligible-sts",
+  "settings-unreadable"
+]);
 var PostPurchaseOfferEligibilityContext = z78.object({
   excludedProductIds: PostPurchaseExcludedProductIds,
   originalLineItems: z78.array(selection2.pick({ productId: true, sellingPlanId: true, variantId: true }))
@@ -4331,7 +4339,8 @@ var PostPurchaseOfferEligibility = z78.discriminatedUnion("status", [
     status: z78.literal("retain")
   }),
   z78.object({ reason: PostPurchaseOfferSkipReason, status: z78.literal("skip") }),
-  z78.object({ reason: z78.literal("eligible-sts").optional(), status: z78.literal("unavailable") })
+  /** The classifier always names a reason; it stays optional so a reasonless answer from before still parses. */
+  z78.object({ reason: PostPurchaseOfferUnavailableReason.optional(), status: z78.literal("unavailable") })
 ]);
 
 // src/schema/postPurchaseOfferPresentation.ts
@@ -6770,6 +6779,7 @@ export {
   PostPurchaseOfferEligibilityContext,
   PostPurchaseOfferPresentation,
   PostPurchaseOfferSkipReason,
+  PostPurchaseOfferUnavailableReason,
   PostPurchaseOptions,
   PostPurchaseOrderAttributes,
   PostPurchaseOrderIdSchema,

package/dist/schema/postPurchaseOfferEligibility.d.ts

@@ -3,6 +3,19 @@ export declare const PostPurchaseOfferSkipReason: z.ZodEnum<{
     empty: "empty";
     "no-eligible-subscription": "no-eligible-subscription";
 }>;
+/**
+ * Why an Offer could not be classified (REB-25054). `eligible-sts` is an STS candidate classified without the STS
+ * opt-in; each other reason names what was unreadable: the caller's context, the merchant's settings, or the
+ * catalog (the data source's products, or its metadata overrides). An ordinary product reason (sold out,
+ * plan-only, no variants, undeclared options) never answers `unavailable`: that member is ineligible instead.
+ */
+export declare const PostPurchaseOfferUnavailableReason: z.ZodEnum<{
+    "catalog-unreadable": "catalog-unreadable";
+    "context-unreadable": "context-unreadable";
+    "eligible-sts": "eligible-sts";
+    "settings-unreadable": "settings-unreadable";
+}>;
+export type PostPurchaseOfferUnavailableReason = z.infer<typeof PostPurchaseOfferUnavailableReason>;
 export declare const PostPurchaseOfferEligibilityContext: z.ZodObject<{
     excludedProductIds: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
     originalLineItems: z.ZodArray<z.ZodObject<{
@@ -49,7 +62,12 @@ export declare const PostPurchaseOfferEligibility: z.ZodDiscriminatedUnion<[z.Zo
     }>;
     status: z.ZodLiteral<"skip">;
 }, z.core.$strip>, z.ZodObject<{
-    reason: z.ZodOptional<z.ZodLiteral<"eligible-sts">>;
+    reason: z.ZodOptional<z.ZodEnum<{
+        "catalog-unreadable": "catalog-unreadable";
+        "context-unreadable": "context-unreadable";
+        "eligible-sts": "eligible-sts";
+        "settings-unreadable": "settings-unreadable";
+    }>>;
     status: z.ZodLiteral<"unavailable">;
 }, z.core.$strip>], "status">;
 export type PostPurchaseOfferEligibility = z.infer<typeof PostPurchaseOfferEligibility>;

package/dist/schema/postPurchaseProductSource.d.ts

@@ -42,6 +42,7 @@ export declare const PostPurchaseProductSource: z.ZodObject<{
         metafields: z.ZodOptional<z.ZodUnknown>;
         options: z.ZodOptional<z.ZodUnknown>;
         productGroupVariants: z.ZodDefault<z.ZodArray<z.ZodUnknown>>;
+        requiresSellingPlan: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
         selectedVariant: z.ZodOptional<z.ZodUnknown>;
         sellingPlanGroups: z.ZodDefault<z.ZodArray<z.ZodObject<{
             discountAmount: z.ZodOptional<z.ZodUnknown>;

package/dist/server/index.cjs

@@ -6128,6 +6128,8 @@ var Product2 = ProductBase.extend({
   metafields: import_zod43.z.unknown().optional(),
   options: import_zod43.z.unknown().optional(),
   productGroupVariants: import_zod43.z.array(import_zod43.z.unknown()).default([]),
+  // REB-25048: the v2 data source flags a subscription-only product here and sends no selling plan groups
+  requiresSellingPlan: import_zod43.z.boolean().nullish(),
   selectedVariant: import_zod43.z.unknown().optional(),
   sellingPlanGroups: import_zod43.z.array(
     OfferProduct.shape.sellingPlanGroups.unwrap().element.extend({
@@ -6187,7 +6189,14 @@ var readPostPurchaseProductSource = (response, report) => {
   const dropped = [];
   const products = data.flatMap((raw, productIndex) => {
     const parsed = Product3.safeParse(raw);
-    if (parsed.success) return [{ product: parsed.data, productIndex }];
+    if (parsed.success) {
+      if (parsed.data.requiresSellingPlan && !parsed.data.sellingPlanGroups.length)
+        drift.push({
+          detail: `Dropped post-purchase product ${parsed.data.id}: data.${productIndex}.requiresSellingPlan`,
+          kind: "product"
+        });
+      return [{ product: parsed.data, productIndex }];
+    }
     const id = Identified.safeParse(raw);
     const issues = parsed.error.issues.map((issue) => ({ ...issue, path: ["data", productIndex, ...issue.path] }));
     const path = issues[0].path.join(".");
@@ -6398,7 +6407,8 @@ var projectPostPurchasePlanCatalog = (normalized, report) => {
         discountPercentage: postPurchasePlanDiscountPercentage(variant2.price, plan.adjustment)
       })),
       productId: product.id,
-      requiresSellingPlan: required[0] ?? false,
+      // REB-25048: a v2 product flags the requirement on itself and carries no selling plan groups
+      requiresSellingPlan: (required[0] ?? false) || product.requiresSellingPlan === true,
       variantId: variant2.id
     });
   } catch {
@@ -6951,7 +6961,7 @@ var oneTimeUnavailable = (normalized, allowCollection, quantity3) => {
     return "Only fixed one-time configuration is supported";
   const product = data[0];
   const variant2 = product.variants[0];
-  if (product.productGroupVariants.length || product.sellingPlanGroups?.some((group) => group.requiresSellingPlan))
+  if (product.productGroupVariants.length || product.requiresSellingPlan === true || product.sellingPlanGroups?.some((group) => group.requiresSellingPlan))
     return "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");
@@ -7491,11 +7501,11 @@ var PostPurchaseMemberPointer = PostPurchaseProgressSchema.shape.members.element
 
 // src/server/normalizePostPurchaseCollection.ts
 var import_zod82 = require("zod");
+var PostPurchaseProductLimit = import_zod82.z.number().int().positive();
 var normalizePostPurchaseCollection = (settings, response, excludedProductIds, report) => {
   const { dropped, normalized, products } = normalizePostPurchaseSource(settings, response, report);
-  const limit = import_zod82.z.number().int().positive();
-  limit.parse(normalized.original.productLimit);
-  const cap = limit.parse(normalized.effective.productLimit);
+  PostPurchaseProductLimit.parse(normalized.original.productLimit);
+  const cap = PostPurchaseProductLimit.parse(normalized.effective.productLimit);
   const prefix = underPostPurchaseCap(products, cap);
   const unread = underPostPurchaseCap(dropped, cap);
   if (unread.length && !prefix.length) throw new import_zod82.ZodError(unread.flatMap(({ issues }) => issues));
@@ -7507,6 +7517,8 @@ var normalizePostPurchaseCollection = (settings, response, excludedProductIds, r
 };
 
 // src/server/postPurchaseVariantCatalog.ts
+var PostPurchaseVariantOptionMismatch = class extends Error {
+};
 var projectPostPurchaseVariantCatalog = (product, settings) => {
   const options2 = PostPurchaseVariantCatalog.shape.options.parse(product.options === void 0 ? [] : product.options).sort((a, b) => a.position - b.position);
   const variants = product.variants.map((variant2) => ({
@@ -7520,7 +7532,7 @@ var projectPostPurchaseVariantCatalog = (product, settings) => {
     throw new Error("Ambiguous post-purchase variant catalog");
   for (const tuple of tuples) {
     if (options2.some(({ position, values: values2 }) => !values2.some((value) => value === tuple[position - 1])) || tuple.some((value, index) => value != null && !options2[index]))
-      throw new Error("Variant option tuple does not match the catalog");
+      throw new PostPurchaseVariantOptionMismatch("Variant option tuple does not match the catalog");
   }
   return PostPurchaseVariantCatalog.parse({
     displayMode: settings.productOptions.variantSelectorDisplayMode,
@@ -7543,6 +7555,12 @@ var projectPostPurchaseVariantCatalog = (product, settings) => {
 var import_zod83 = require("zod");
 var selection2 = PreparedPostPurchaseProduct.shape.selection;
 var PostPurchaseOfferSkipReason = import_zod83.z.enum(["empty", "no-eligible-subscription"]);
+var PostPurchaseOfferUnavailableReason = import_zod83.z.enum([
+  "catalog-unreadable",
+  "context-unreadable",
+  "eligible-sts",
+  "settings-unreadable"
+]);
 var PostPurchaseOfferEligibilityContext = import_zod83.z.object({
   excludedProductIds: PostPurchaseExcludedProductIds,
   originalLineItems: import_zod83.z.array(selection2.pick({ productId: true, sellingPlanId: true, variantId: true }))
@@ -7563,7 +7581,8 @@ var PostPurchaseOfferEligibility = import_zod83.z.discriminatedUnion("status", [
     status: import_zod83.z.literal("retain")
   }),
   import_zod83.z.object({ reason: PostPurchaseOfferSkipReason, status: import_zod83.z.literal("skip") }),
-  import_zod83.z.object({ reason: import_zod83.z.literal("eligible-sts").optional(), status: import_zod83.z.literal("unavailable") })
+  /** The classifier always names a reason; it stays optional so a reasonless answer from before still parses. */
+  import_zod83.z.object({ reason: PostPurchaseOfferUnavailableReason.optional(), status: import_zod83.z.literal("unavailable") })
 ]);
 
 // src/schema/postPurchaseQuantity.ts
@@ -8047,14 +8066,13 @@ var preparePostPurchaseCollectionView = (widgetId, settings, response, report, r
 };
 
 // src/server/postPurchaseMemberEligibility.ts
-var PostPurchaseInventoryUnavailable = class extends Error {
-};
-var postPurchaseMemberEligibility = (normalized, product, excluded) => {
+var eligibility = (normalized, product, excluded) => {
   if (product.productGroupVariants.length) {
     const group = readPostPurchaseGroup(product, normalized.effective, excluded);
+    if (!group.entries.length) return void 0;
     return group.entries.map(({ product: option }) => postPurchaseMemberEligibility(normalized, option)).some(Boolean);
   }
-  if (!product.variants.length) throw new Error("Unsupported catalog");
+  if (!product.variants.length) return false;
   const variants = projectPostPurchaseVariantCatalog(product, normalized.effective).variants;
   const catalogs = product.variants.map((variant2) => {
     const catalog = projectPostPurchasePlanCatalog({
@@ -8062,23 +8080,31 @@ var postPurchaseMemberEligibility = (normalized, product, excluded) => {
       data: [{ ...product, variants: [variant2] }]
     });
     if (!catalog) throw new Error("Unreadable subscription catalog");
-    if (normalized.effective.productType === "one-time" && catalog.requiresSellingPlan)
-      throw new Error("Unsupported purchase mode");
     return catalog;
   });
-  if (!variants.some((variant2) => variant2.available))
-    throw new PostPurchaseInventoryUnavailable("Unavailable inventory");
   return catalogs.some(
     (catalog, index) => variants[index].available && (normalized.effective.productType !== "subscription" && !catalog.requiresSellingPlan || normalized.effective.productType !== "one-time" && catalog.plans.length > 0)
   );
 };
+var postPurchaseMemberEligibility = (normalized, product, excluded) => {
+  try {
+    return eligibility(normalized, product, excluded);
+  } catch (error) {
+    if (error instanceof PostPurchaseVariantOptionMismatch) return false;
+    throw error;
+  }
+};
 
 // src/server/classifyPostPurchaseOffer.ts
 var identities = (members) => members.map(({ product, productIndex }) => ({ productId: product.id, productIndex }));
 var classifyPostPurchaseOffer = (settings, response, context, options2) => {
+  let unreadable = "context-unreadable";
   try {
     const trusted = PostPurchaseOfferEligibilityContext.parse(context);
     const { sts: stsMode = false } = PostPurchaseStsOptions.parse(options2 ?? {});
+    unreadable = "settings-unreadable";
+    PostPurchaseProductLimit.parse(PostPurchaseProductSettings.parse(deepCamelCase(settings)).productLimit);
+    unreadable = "catalog-unreadable";
     const { members, normalized } = normalizePostPurchaseCollection(settings, response);
     const configurations = [normalized.original, normalized.effective];
     const stsEnabled = configurations.some((config) => config.upgradeToSubscription.allow);
@@ -8091,33 +8117,28 @@ var classifyPostPurchaseOffer = (settings, response, context, options2) => {
     ))
       return { reason: "eligible-sts", status: "unavailable" };
     if (normalized.effective.productType !== "one-time" || sts) {
-      configurations.forEach((config) => PostPurchaseSubscriptionSettings.parse(config.subscription));
+      unreadable = "settings-unreadable";
+      PostPurchaseSubscriptionSettings.parse(normalized.original.subscription);
+      unreadable = "catalog-unreadable";
+      PostPurchaseSubscriptionSettings.parse(normalized.effective.subscription);
     }
     const lines = trusted.originalLineItems;
     const stsMembers = sts ? members.filter(({ product }) => postPurchaseStsLine(normalized, product, lines)) : [];
     if (stsMembers.length) return { members: identities(stsMembers), mode: "sts", status: "retain" };
-    const classified = members.map((member) => {
-      try {
-        return {
-          ...member,
-          eligible: postPurchaseMemberEligibility(normalized, member.product, trusted.excludedProductIds)
-        };
-      } catch (error) {
-        if (error instanceof PostPurchaseInventoryUnavailable && !member.product.productGroupVariants.length && trusted.excludedProductIds.includes(member.product.id))
-          return { ...member, eligible: false };
-        throw error;
-      }
-    });
+    const classified = members.map((member) => ({
+      ...member,
+      eligible: postPurchaseMemberEligibility(normalized, member.product, trusted.excludedProductIds)
+    }));
     if (!members.length) return { reason: "empty", status: "skip" };
     if (stsEnabled) return { reason: "no-eligible-subscription", status: "skip" };
     const candidates = classified.filter(
-      ({ product }) => product.productGroupVariants.length ? readPostPurchaseGroup(product, normalized.effective, trusted.excludedProductIds).entries.length > 0 : !trusted.excludedProductIds.includes(product.id)
+      ({ eligible, product }) => product.productGroupVariants.length ? eligible !== void 0 : !trusted.excludedProductIds.includes(product.id)
     );
     if (!candidates.length) return { reason: "empty", status: "skip" };
     const retained = candidates.filter(({ eligible }) => eligible);
     return retained.length ? { members: identities(retained), status: "retain" } : { reason: "no-eligible-subscription", status: "skip" };
   } catch {
-    return { status: "unavailable" };
+    return { reason: unreadable, status: "unavailable" };
   }
 };
 

package/dist/server/index.mjs

@@ -6055,6 +6055,8 @@ var Product2 = ProductBase.extend({
   metafields: z43.unknown().optional(),
   options: z43.unknown().optional(),
   productGroupVariants: z43.array(z43.unknown()).default([]),
+  // REB-25048: the v2 data source flags a subscription-only product here and sends no selling plan groups
+  requiresSellingPlan: z43.boolean().nullish(),
   selectedVariant: z43.unknown().optional(),
   sellingPlanGroups: z43.array(
     OfferProduct.shape.sellingPlanGroups.unwrap().element.extend({
@@ -6114,7 +6116,14 @@ var readPostPurchaseProductSource = (response, report) => {
   const dropped = [];
   const products = data.flatMap((raw, productIndex) => {
     const parsed = Product3.safeParse(raw);
-    if (parsed.success) return [{ product: parsed.data, productIndex }];
+    if (parsed.success) {
+      if (parsed.data.requiresSellingPlan && !parsed.data.sellingPlanGroups.length)
+        drift.push({
+          detail: `Dropped post-purchase product ${parsed.data.id}: data.${productIndex}.requiresSellingPlan`,
+          kind: "product"
+        });
+      return [{ product: parsed.data, productIndex }];
+    }
     const id = Identified.safeParse(raw);
     const issues = parsed.error.issues.map((issue) => ({ ...issue, path: ["data", productIndex, ...issue.path] }));
     const path = issues[0].path.join(".");
@@ -6325,7 +6334,8 @@ var projectPostPurchasePlanCatalog = (normalized, report) => {
         discountPercentage: postPurchasePlanDiscountPercentage(variant2.price, plan.adjustment)
       })),
       productId: product.id,
-      requiresSellingPlan: required[0] ?? false,
+      // REB-25048: a v2 product flags the requirement on itself and carries no selling plan groups
+      requiresSellingPlan: (required[0] ?? false) || product.requiresSellingPlan === true,
       variantId: variant2.id
     });
   } catch {
@@ -6878,7 +6888,7 @@ var oneTimeUnavailable = (normalized, allowCollection, quantity3) => {
     return "Only fixed one-time configuration is supported";
   const product = data[0];
   const variant2 = product.variants[0];
-  if (product.productGroupVariants.length || product.sellingPlanGroups?.some((group) => group.requiresSellingPlan))
+  if (product.productGroupVariants.length || product.requiresSellingPlan === true || product.sellingPlanGroups?.some((group) => group.requiresSellingPlan))
     return "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");
@@ -7418,11 +7428,11 @@ var PostPurchaseMemberPointer = PostPurchaseProgressSchema.shape.members.element
 
 // src/server/normalizePostPurchaseCollection.ts
 import { z as z82, ZodError } from "zod";
+var PostPurchaseProductLimit = z82.number().int().positive();
 var normalizePostPurchaseCollection = (settings, response, excludedProductIds, report) => {
   const { dropped, normalized, products } = normalizePostPurchaseSource(settings, response, report);
-  const limit = z82.number().int().positive();
-  limit.parse(normalized.original.productLimit);
-  const cap = limit.parse(normalized.effective.productLimit);
+  PostPurchaseProductLimit.parse(normalized.original.productLimit);
+  const cap = PostPurchaseProductLimit.parse(normalized.effective.productLimit);
   const prefix = underPostPurchaseCap(products, cap);
   const unread = underPostPurchaseCap(dropped, cap);
   if (unread.length && !prefix.length) throw new ZodError(unread.flatMap(({ issues }) => issues));
@@ -7434,6 +7444,8 @@ var normalizePostPurchaseCollection = (settings, response, excludedProductIds, r
 };
 
 // src/server/postPurchaseVariantCatalog.ts
+var PostPurchaseVariantOptionMismatch = class extends Error {
+};
 var projectPostPurchaseVariantCatalog = (product, settings) => {
   const options2 = PostPurchaseVariantCatalog.shape.options.parse(product.options === void 0 ? [] : product.options).sort((a, b) => a.position - b.position);
   const variants = product.variants.map((variant2) => ({
@@ -7447,7 +7459,7 @@ var projectPostPurchaseVariantCatalog = (product, settings) => {
     throw new Error("Ambiguous post-purchase variant catalog");
   for (const tuple of tuples) {
     if (options2.some(({ position, values: values2 }) => !values2.some((value) => value === tuple[position - 1])) || tuple.some((value, index) => value != null && !options2[index]))
-      throw new Error("Variant option tuple does not match the catalog");
+      throw new PostPurchaseVariantOptionMismatch("Variant option tuple does not match the catalog");
   }
   return PostPurchaseVariantCatalog.parse({
     displayMode: settings.productOptions.variantSelectorDisplayMode,
@@ -7470,6 +7482,12 @@ var projectPostPurchaseVariantCatalog = (product, settings) => {
 import { z as z83 } from "zod";
 var selection2 = PreparedPostPurchaseProduct.shape.selection;
 var PostPurchaseOfferSkipReason = z83.enum(["empty", "no-eligible-subscription"]);
+var PostPurchaseOfferUnavailableReason = z83.enum([
+  "catalog-unreadable",
+  "context-unreadable",
+  "eligible-sts",
+  "settings-unreadable"
+]);
 var PostPurchaseOfferEligibilityContext = z83.object({
   excludedProductIds: PostPurchaseExcludedProductIds,
   originalLineItems: z83.array(selection2.pick({ productId: true, sellingPlanId: true, variantId: true }))
@@ -7490,7 +7508,8 @@ var PostPurchaseOfferEligibility = z83.discriminatedUnion("status", [
     status: z83.literal("retain")
   }),
   z83.object({ reason: PostPurchaseOfferSkipReason, status: z83.literal("skip") }),
-  z83.object({ reason: z83.literal("eligible-sts").optional(), status: z83.literal("unavailable") })
+  /** The classifier always names a reason; it stays optional so a reasonless answer from before still parses. */
+  z83.object({ reason: PostPurchaseOfferUnavailableReason.optional(), status: z83.literal("unavailable") })
 ]);
 
 // src/schema/postPurchaseQuantity.ts
@@ -7974,14 +7993,13 @@ var preparePostPurchaseCollectionView = (widgetId, settings, response, report, r
 };
 
 // src/server/postPurchaseMemberEligibility.ts
-var PostPurchaseInventoryUnavailable = class extends Error {
-};
-var postPurchaseMemberEligibility = (normalized, product, excluded) => {
+var eligibility = (normalized, product, excluded) => {
   if (product.productGroupVariants.length) {
     const group = readPostPurchaseGroup(product, normalized.effective, excluded);
+    if (!group.entries.length) return void 0;
     return group.entries.map(({ product: option }) => postPurchaseMemberEligibility(normalized, option)).some(Boolean);
   }
-  if (!product.variants.length) throw new Error("Unsupported catalog");
+  if (!product.variants.length) return false;
   const variants = projectPostPurchaseVariantCatalog(product, normalized.effective).variants;
   const catalogs = product.variants.map((variant2) => {
     const catalog = projectPostPurchasePlanCatalog({
@@ -7989,23 +8007,31 @@ var postPurchaseMemberEligibility = (normalized, product, excluded) => {
       data: [{ ...product, variants: [variant2] }]
     });
     if (!catalog) throw new Error("Unreadable subscription catalog");
-    if (normalized.effective.productType === "one-time" && catalog.requiresSellingPlan)
-      throw new Error("Unsupported purchase mode");
     return catalog;
   });
-  if (!variants.some((variant2) => variant2.available))
-    throw new PostPurchaseInventoryUnavailable("Unavailable inventory");
   return catalogs.some(
     (catalog, index) => variants[index].available && (normalized.effective.productType !== "subscription" && !catalog.requiresSellingPlan || normalized.effective.productType !== "one-time" && catalog.plans.length > 0)
   );
 };
+var postPurchaseMemberEligibility = (normalized, product, excluded) => {
+  try {
+    return eligibility(normalized, product, excluded);
+  } catch (error) {
+    if (error instanceof PostPurchaseVariantOptionMismatch) return false;
+    throw error;
+  }
+};
 
 // src/server/classifyPostPurchaseOffer.ts
 var identities = (members) => members.map(({ product, productIndex }) => ({ productId: product.id, productIndex }));
 var classifyPostPurchaseOffer = (settings, response, context, options2) => {
+  let unreadable = "context-unreadable";
   try {
     const trusted = PostPurchaseOfferEligibilityContext.parse(context);
     const { sts: stsMode = false } = PostPurchaseStsOptions.parse(options2 ?? {});
+    unreadable = "settings-unreadable";
+    PostPurchaseProductLimit.parse(PostPurchaseProductSettings.parse(deepCamelCase(settings)).productLimit);
+    unreadable = "catalog-unreadable";
     const { members, normalized } = normalizePostPurchaseCollection(settings, response);
     const configurations = [normalized.original, normalized.effective];
     const stsEnabled = configurations.some((config) => config.upgradeToSubscription.allow);
@@ -8018,33 +8044,28 @@ var classifyPostPurchaseOffer = (settings, response, context, options2) => {
     ))
       return { reason: "eligible-sts", status: "unavailable" };
     if (normalized.effective.productType !== "one-time" || sts) {
-      configurations.forEach((config) => PostPurchaseSubscriptionSettings.parse(config.subscription));
+      unreadable = "settings-unreadable";
+      PostPurchaseSubscriptionSettings.parse(normalized.original.subscription);
+      unreadable = "catalog-unreadable";
+      PostPurchaseSubscriptionSettings.parse(normalized.effective.subscription);
     }
     const lines = trusted.originalLineItems;
     const stsMembers = sts ? members.filter(({ product }) => postPurchaseStsLine(normalized, product, lines)) : [];
     if (stsMembers.length) return { members: identities(stsMembers), mode: "sts", status: "retain" };
-    const classified = members.map((member) => {
-      try {
-        return {
-          ...member,
-          eligible: postPurchaseMemberEligibility(normalized, member.product, trusted.excludedProductIds)
-        };
-      } catch (error) {
-        if (error instanceof PostPurchaseInventoryUnavailable && !member.product.productGroupVariants.length && trusted.excludedProductIds.includes(member.product.id))
-          return { ...member, eligible: false };
-        throw error;
-      }
-    });
+    const classified = members.map((member) => ({
+      ...member,
+      eligible: postPurchaseMemberEligibility(normalized, member.product, trusted.excludedProductIds)
+    }));
     if (!members.length) return { reason: "empty", status: "skip" };
     if (stsEnabled) return { reason: "no-eligible-subscription", status: "skip" };
     const candidates = classified.filter(
-      ({ product }) => product.productGroupVariants.length ? readPostPurchaseGroup(product, normalized.effective, trusted.excludedProductIds).entries.length > 0 : !trusted.excludedProductIds.includes(product.id)
+      ({ eligible, product }) => product.productGroupVariants.length ? eligible !== void 0 : !trusted.excludedProductIds.includes(product.id)
     );
     if (!candidates.length) return { reason: "empty", status: "skip" };
     const retained = candidates.filter(({ eligible }) => eligible);
     return retained.length ? { members: identities(retained), status: "retain" } : { reason: "no-eligible-subscription", status: "skip" };
   } catch {
-    return { status: "unavailable" };
+    return { reason: unreadable, status: "unavailable" };
   }
 };
 

package/dist/server/normalizePostPurchaseCollection.d.ts

@@ -1,5 +1,8 @@
+import { z } from 'zod';
 import { PostPurchaseExcludedProductIds } from '../schema/postPurchaseProductCollectionView';
 import type { Reporter } from '../server/shared';
+/** A collection's `productLimit`, original or effective: a positive whole number. */
+export declare const PostPurchaseProductLimit: z.ZodNumber;
 /**
  * Preserve the original capped positions before applying product-wide exclusions. `productLimit` caps raw
  * positions, and a member's `productIndex` is its raw position: a product the schema dropped leaves its slot
@@ -51,6 +54,7 @@ export declare const normalizePostPurchaseCollection: (settings: unknown, respon
             } | undefined;
             metafields?: unknown;
             options?: unknown;
+            requiresSellingPlan?: boolean | null | undefined;
             selectedVariant?: unknown;
         };
         productIndex: number;
@@ -96,6 +100,7 @@ export declare const normalizePostPurchaseCollection: (settings: unknown, respon
             } | undefined;
             metafields?: unknown;
             options?: unknown;
+            requiresSellingPlan?: boolean | null | undefined;
             selectedVariant?: unknown;
         }[];
         effective: {

package/dist/server/normalizePostPurchaseProduct.d.ts

@@ -52,6 +52,7 @@ export declare const normalizePostPurchaseSource: (settings: unknown, response:
             } | undefined;
             metafields?: unknown;
             options?: unknown;
+            requiresSellingPlan?: boolean | null | undefined;
             selectedVariant?: unknown;
         }[];
         effective: {
@@ -254,6 +255,7 @@ export declare const normalizePostPurchaseSource: (settings: unknown, response:
             } | undefined;
             metafields?: unknown;
             options?: unknown;
+            requiresSellingPlan?: boolean | null | undefined;
             selectedVariant?: unknown;
         };
         productIndex: number;
@@ -317,6 +319,7 @@ export declare const normalizePostPurchaseProduct: (settings: unknown, response:
         } | undefined;
         metafields?: unknown;
         options?: unknown;
+        requiresSellingPlan?: boolean | null | undefined;
         selectedVariant?: unknown;
     }[];
     effective: {

package/dist/server/postPurchaseMemberEligibility.d.ts

@@ -1,7 +1,13 @@
 import type { PostPurchaseExcludedProductIds } from '../schema/postPurchaseProductCollectionView';
 import type { normalizePostPurchaseProduct } from '../server/normalizePostPurchaseProduct';
-/** The member's catalog is readable, but no variant is in stock. */
-export declare class PostPurchaseInventoryUnavailable extends Error {
-}
-/** Catalog facts only: preparation still owns defaults, quantity, terms, and presentation. */
-export declare const postPurchaseMemberEligibility: (normalized: ReturnType<typeof normalizePostPurchaseProduct>, product: ReturnType<typeof normalizePostPurchaseProduct>["data"][number], excluded?: PostPurchaseExcludedProductIds) => boolean;
+type Normalized = ReturnType<typeof normalizePostPurchaseProduct>;
+/**
+ * Catalog facts only: preparation still owns defaults, quantity, terms, and presentation. `false` is an ordinary
+ * product reason (REB-25054): no available variant, plan-only on a one-time Offer, or option values the product
+ * does not declare, for the member or, for a group, every sibling. A sibling with undeclared options leaves its
+ * whole group ineligible, as preparation cannot read that group either. `undefined` is a group whose every
+ * sibling is excluded, so nothing is left to offer; the group is read before exclusions apply, though, so an
+ * excluded sibling with undeclared options still answers `false`. A throw is unreadable data.
+ */
+export declare const postPurchaseMemberEligibility: (normalized: Normalized, product: Normalized["data"][number], excluded?: PostPurchaseExcludedProductIds) => boolean | undefined;
+export {};

package/dist/server/postPurchaseSts.d.ts

@@ -60,6 +60,7 @@ export declare const postPurchaseStsLine: <T extends Line>(normalized: Normalize
         } | undefined;
         metafields?: unknown;
         options?: unknown;
+        requiresSellingPlan?: boolean | null | undefined;
         selectedVariant?: unknown;
     }[];
     line: T;

package/dist/server/postPurchaseVariantCatalog.d.ts

@@ -1,3 +1,9 @@
 import { PostPurchaseVariantCatalog } from '../schema/postPurchaseVariantCatalog';
 import type { normalizePostPurchaseProduct } from '../server/normalizePostPurchaseProduct';
+/**
+ * A variant carries an option value its product does not declare (an optionless product, say): the merchandise is
+ * readable but cannot be offered as it stands, so member eligibility leaves it out rather than failing the Offer.
+ */
+export declare class PostPurchaseVariantOptionMismatch extends Error {
+}
 export declare const projectPostPurchaseVariantCatalog: (product: ReturnType<typeof normalizePostPurchaseProduct>["data"][number], settings: ReturnType<typeof normalizePostPurchaseProduct>["effective"]) => PostPurchaseVariantCatalog;

package/dist/server/preparePostPurchaseMemberView.d.ts

@@ -651,6 +651,7 @@ export declare const prepareMember: (widgetId: number, settings: unknown, respon
             } | undefined;
             metafields?: unknown;
             options?: unknown;
+            requiresSellingPlan?: boolean | null | undefined;
             selectedVariant?: unknown;
         }[];
         effective: {
@@ -1468,6 +1469,7 @@ export declare const prepareMember: (widgetId: number, settings: unknown, respon
             } | undefined;
             metafields?: unknown;
             options?: unknown;
+            requiresSellingPlan?: boolean | null | undefined;
             selectedVariant?: unknown;
         }[];
         effective: {

package/dist/server/preparePostPurchaseStsMember.d.ts

@@ -656,6 +656,7 @@ export declare const preparePostPurchaseStsMember: (widgetId: number, settings:
             } | undefined;
             metafields?: unknown;
             options?: unknown;
+            requiresSellingPlan?: boolean | null | undefined;
             selectedVariant?: unknown;
         }[];
         effective: {

package/dist/server/projectPostPurchaseProduct.d.ts

@@ -159,6 +159,7 @@ export declare const projectPostPurchaseProduct: ({ data, effective, metadata, o
         } | undefined;
         metafields?: unknown;
         options?: unknown;
+        requiresSellingPlan?: boolean | null | undefined;
         selectedVariant?: unknown;
     };
     selection: {

package/dist/server/readPostPurchaseGroup.d.ts

@@ -75,6 +75,7 @@ export declare const readPostPurchaseGroup: (product: ReturnType<typeof normaliz
                 productQuantity?: number | undefined;
             } | undefined;
             metafields?: unknown;
+            requiresSellingPlan?: boolean | null | undefined;
             selectedVariant?: unknown;
         };
         variantCatalog: {

package/dist/server/readPostPurchaseGroupSelection.d.ts

@@ -81,6 +81,7 @@ export declare const readPostPurchaseGroupSelection: (settings: unknown, respons
                 productQuantity?: number | undefined;
             } | undefined;
             metafields?: unknown;
+            requiresSellingPlan?: boolean | null | undefined;
             selectedVariant?: unknown;
         }[];
         metadata: {

package/dist/server/readPostPurchaseProductSource.d.ts

@@ -9,6 +9,10 @@ import type { Reporter } from '../server/shared';
  * one request (a re-parse or clone per projection reports the drops again). The envelope (an object, `data`
  * an array, readable `metadata`) still throws.
  *
+ * A product that parses but requires a selling plan on itself with no selling plan groups (a v2 subscription-only
+ * product, REB-25048) is kept for eligibility to drop, and reported here as the same once-per-response drift,
+ * naming its `requiresSellingPlan` path: it has no plan to sell it with and may never be sold one-time.
+ *
  * Every survivor keeps `productIndex`, its position in the raw `data` array: Decision, Render and Offer
  * members identify a product by that index, so a drop never renumbers the products after it. `dropped` keeps
  * each drop's `productIndex` and its zod issues with paths from the source root, so a caller can fail a source
@@ -63,6 +67,7 @@ export declare const readPostPurchaseProductSource: (response: unknown, report?:
             } | undefined;
             metafields?: unknown;
             options?: unknown;
+            requiresSellingPlan?: boolean | null | undefined;
             selectedVariant?: unknown;
         };
         productIndex: number;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rebuy/rebuy",
-    "version": "3.56.1",
+    "version": "3.56.3",
     "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.",