@rebuy/rebuy 3.56.2 → 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,
@@ -4792,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 }))
@@ -4812,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

@@ -4313,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 }))
@@ -4333,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
@@ -6772,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/server/index.cjs

@@ -7501,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));
@@ -7517,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) => ({
@@ -7530,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,
@@ -7553,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 }))
@@ -7573,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
@@ -8057,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({
@@ -8072,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" && product.sellingPlanGroups.some((group) => group.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);
@@ -8101,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

@@ -7428,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));
@@ -7444,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) => ({
@@ -7457,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,
@@ -7480,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 }))
@@ -7500,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
@@ -7984,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({
@@ -7999,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" && product.sellingPlanGroups.some((group) => group.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);
@@ -8028,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

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/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/package.json

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