@rebuy/rebuy 3.56.2 → 3.57.0

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/classifyPostPurchaseOffer.d.ts

@@ -1,5 +1,8 @@
 import { type z } from 'zod';
 import { type PostPurchaseOfferEligibility, PostPurchaseOfferEligibilityContext, PostPurchaseStsOptions } from '../schema/postPurchaseOfferEligibility';
+import type { Reporter } from '../server/shared';
 export declare const classifyPostPurchaseOffer: (settings: unknown, response: unknown, context: z.input<typeof PostPurchaseOfferEligibilityContext>, 
 /** STS opt-in; absent or `{ sts: false }` keeps every pre-STS outcome. */
-options?: PostPurchaseStsOptions) => PostPurchaseOfferEligibility;
+options?: PostPurchaseStsOptions, 
+/** Hears each purchased STS candidate whose plan data cannot be read, once per response (REB-25050). */
+report?: Reporter) => PostPurchaseOfferEligibility;

package/dist/server/index.cjs

@@ -6172,17 +6172,30 @@ var PostPurchaseProductSettings = PostPurchaseSettings.pick({
 
 // src/server/readPostPurchaseProductSource.ts
 var import_zod45 = require("zod");
-var Envelope = PostPurchaseProductSource.extend({ data: import_zod45.z.array(import_zod45.z.unknown()) });
-var Product3 = PostPurchaseProductSource.shape.data.element;
-var Identified = import_zod45.z.object({ id: PostPurchaseProductId });
+
+// src/server/postPurchaseResponseDrift.ts
 var heard = /* @__PURE__ */ new WeakMap();
-var firstHearing = (response, report) => {
-  const reporters = heard.get(response) ?? /* @__PURE__ */ new WeakSet();
+var sources = /* @__PURE__ */ new WeakMap();
+var rememberPostPurchaseProductSource = (product, response, productIndex) => {
+  sources.set(product, { productIndex, response });
+};
+var postPurchaseProductSourceOf = (product) => sources.get(product);
+var reportOncePerResponse = (response, report, events) => {
+  const reporters = heard.get(response) ?? /* @__PURE__ */ new WeakMap();
   heard.set(response, reporters);
-  if (reporters.has(report)) return false;
-  reporters.add(report);
-  return true;
+  const details = reporters.get(report) ?? /* @__PURE__ */ new Set();
+  reporters.set(report, details);
+  for (const event of events) {
+    if (details.has(event.detail)) continue;
+    details.add(event.detail);
+    report(event);
+  }
 };
+
+// src/server/readPostPurchaseProductSource.ts
+var Envelope = PostPurchaseProductSource.extend({ data: import_zod45.z.array(import_zod45.z.unknown()) });
+var Product3 = PostPurchaseProductSource.shape.data.element;
+var Identified = import_zod45.z.object({ id: PostPurchaseProductId });
 var readPostPurchaseProductSource = (response, report) => {
   const { data, metadata } = Envelope.parse(deepCamelCase(response));
   const drift = [];
@@ -6190,6 +6203,7 @@ var readPostPurchaseProductSource = (response, report) => {
   const products = data.flatMap((raw, productIndex) => {
     const parsed = Product3.safeParse(raw);
     if (parsed.success) {
+      rememberPostPurchaseProductSource(parsed.data, response, productIndex);
       if (parsed.data.requiresSellingPlan && !parsed.data.sellingPlanGroups.length)
         drift.push({
           detail: `Dropped post-purchase product ${parsed.data.id}: data.${productIndex}.requiresSellingPlan`,
@@ -6207,7 +6221,7 @@ var readPostPurchaseProductSource = (response, report) => {
     });
     return [];
   });
-  if (report && drift.length && firstHearing(response, report)) drift.forEach((event) => report(event));
+  if (report && drift.length) reportOncePerResponse(response, report, drift);
   return { dropped, metadata, products };
 };
 
@@ -6353,7 +6367,8 @@ var Groups = import_zod52.z.array(
     sellingPlans: import_zod52.z.unknown()
   })
 );
-var Allocations = import_zod52.z.array(import_zod52.z.object({ sellingPlanGroupId: import_zod52.z.string().min(1) })).default([]);
+var PostPurchasePlanAllocations = import_zod52.z.array(import_zod52.z.object({ sellingPlanGroupId: import_zod52.z.string().min(1) }));
+var Allocations = PostPurchasePlanAllocations.default([]);
 var Plans = import_zod52.z.array(
   PostPurchasePlanOption.pick({ id: true, name: true }).extend({
     options: import_zod52.z.array(import_zod52.z.object({ value: import_zod52.z.string().min(1) })).min(1),
@@ -7501,11 +7516,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 +7532,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 +7547,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 +7570,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 +7596,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
@@ -7615,18 +7639,30 @@ var readPostPurchaseQuantity = ({
 
 // src/server/postPurchaseSts.ts
 var stsAllowed = ({ effective, original }) => [original, effective].some((config) => config.upgradeToSubscription.allow);
-var postPurchaseStsLine = (normalized, product, lines, variantId) => {
+var reportUnreadableStsLine = (product, field, report) => {
+  const source2 = postPurchaseProductSourceOf(product);
+  const path = source2 ? `data.${source2.productIndex}.${field}` : field;
+  const detail = `Unreadable post-purchase STS product ${product.id}: ${path}`;
+  reportOncePerResponse(source2?.response ?? product, report, [{ detail, kind: "product" }]);
+};
+var postPurchaseStsLine = (normalized, product, lines, variantId, report) => {
   if (!product.sellingPlanGroups?.length || product.productGroupVariants.length) return void 0;
-  for (const variant2 of product.variants) {
+  const modern = typeof product.sellingPlanGroups[0].id !== "number";
+  for (const [index, variant2] of product.variants.entries()) {
     const matched = lines.filter((line) => line.sellingPlanId === void 0 && line.variantId === variant2.id);
     const data = [{ ...product, variants: [variant2] }];
-    if ((variantId === void 0 || variant2.id === variantId) && matched.length === 1 && postPurchaseVariantAvailable(variant2) && projectPostPurchasePlanCatalog({ ...normalized, data })?.plans.length)
-      return { data, line: matched[0] };
+    if ((variantId === void 0 || variant2.id === variantId) && matched.length === 1 && postPurchaseVariantAvailable(variant2)) {
+      const unread = [];
+      if (projectPostPurchasePlanCatalog({ ...normalized, data }, (event) => unread.push(event))?.plans.length)
+        return { data, line: matched[0] };
+      const field = modern && !PostPurchasePlanAllocations.safeParse(variant2.sellingPlanAllocations).success ? `variants.${index}.sellingPlanAllocations` : unread.length ? "sellingPlanGroups" : void 0;
+      if (report && field) reportUnreadableStsLine(product, field, report);
+    }
   }
 };
 var preparePostPurchaseStsView = (widgetId, normalized, product, context, requested, report) => {
   const { originalLineItems } = PostPurchaseStsContext.parse(context);
-  const found = postPurchaseStsLine(normalized, product, originalLineItems, requested.variantId);
+  const found = postPurchaseStsLine(normalized, product, originalLineItems, requested.variantId, report);
   if (!found) return null;
   const whole = found.line.quantity;
   if (requested.quantity !== void 0 && requested.quantity !== whole)
@@ -8057,14 +8093,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 +8107,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) => {
+var classifyPostPurchaseOffer = (settings, response, context, options2, report) => {
+  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 +8144,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)) : [];
+    const stsMembers = sts ? members.filter(({ product }) => postPurchaseStsLine(normalized, product, lines, void 0, report)) : [];
     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

@@ -6099,17 +6099,30 @@ var PostPurchaseProductSettings = PostPurchaseSettings.pick({
 
 // src/server/readPostPurchaseProductSource.ts
 import { z as z45 } from "zod";
-var Envelope = PostPurchaseProductSource.extend({ data: z45.array(z45.unknown()) });
-var Product3 = PostPurchaseProductSource.shape.data.element;
-var Identified = z45.object({ id: PostPurchaseProductId });
+
+// src/server/postPurchaseResponseDrift.ts
 var heard = /* @__PURE__ */ new WeakMap();
-var firstHearing = (response, report) => {
-  const reporters = heard.get(response) ?? /* @__PURE__ */ new WeakSet();
+var sources = /* @__PURE__ */ new WeakMap();
+var rememberPostPurchaseProductSource = (product, response, productIndex) => {
+  sources.set(product, { productIndex, response });
+};
+var postPurchaseProductSourceOf = (product) => sources.get(product);
+var reportOncePerResponse = (response, report, events) => {
+  const reporters = heard.get(response) ?? /* @__PURE__ */ new WeakMap();
   heard.set(response, reporters);
-  if (reporters.has(report)) return false;
-  reporters.add(report);
-  return true;
+  const details = reporters.get(report) ?? /* @__PURE__ */ new Set();
+  reporters.set(report, details);
+  for (const event of events) {
+    if (details.has(event.detail)) continue;
+    details.add(event.detail);
+    report(event);
+  }
 };
+
+// src/server/readPostPurchaseProductSource.ts
+var Envelope = PostPurchaseProductSource.extend({ data: z45.array(z45.unknown()) });
+var Product3 = PostPurchaseProductSource.shape.data.element;
+var Identified = z45.object({ id: PostPurchaseProductId });
 var readPostPurchaseProductSource = (response, report) => {
   const { data, metadata } = Envelope.parse(deepCamelCase(response));
   const drift = [];
@@ -6117,6 +6130,7 @@ var readPostPurchaseProductSource = (response, report) => {
   const products = data.flatMap((raw, productIndex) => {
     const parsed = Product3.safeParse(raw);
     if (parsed.success) {
+      rememberPostPurchaseProductSource(parsed.data, response, productIndex);
       if (parsed.data.requiresSellingPlan && !parsed.data.sellingPlanGroups.length)
         drift.push({
           detail: `Dropped post-purchase product ${parsed.data.id}: data.${productIndex}.requiresSellingPlan`,
@@ -6134,7 +6148,7 @@ var readPostPurchaseProductSource = (response, report) => {
     });
     return [];
   });
-  if (report && drift.length && firstHearing(response, report)) drift.forEach((event) => report(event));
+  if (report && drift.length) reportOncePerResponse(response, report, drift);
   return { dropped, metadata, products };
 };
 
@@ -6280,7 +6294,8 @@ var Groups = z52.array(
     sellingPlans: z52.unknown()
   })
 );
-var Allocations = z52.array(z52.object({ sellingPlanGroupId: z52.string().min(1) })).default([]);
+var PostPurchasePlanAllocations = z52.array(z52.object({ sellingPlanGroupId: z52.string().min(1) }));
+var Allocations = PostPurchasePlanAllocations.default([]);
 var Plans = z52.array(
   PostPurchasePlanOption.pick({ id: true, name: true }).extend({
     options: z52.array(z52.object({ value: z52.string().min(1) })).min(1),
@@ -7428,11 +7443,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 +7459,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 +7474,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 +7497,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 +7523,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
@@ -7542,18 +7566,30 @@ var readPostPurchaseQuantity = ({
 
 // src/server/postPurchaseSts.ts
 var stsAllowed = ({ effective, original }) => [original, effective].some((config) => config.upgradeToSubscription.allow);
-var postPurchaseStsLine = (normalized, product, lines, variantId) => {
+var reportUnreadableStsLine = (product, field, report) => {
+  const source2 = postPurchaseProductSourceOf(product);
+  const path = source2 ? `data.${source2.productIndex}.${field}` : field;
+  const detail = `Unreadable post-purchase STS product ${product.id}: ${path}`;
+  reportOncePerResponse(source2?.response ?? product, report, [{ detail, kind: "product" }]);
+};
+var postPurchaseStsLine = (normalized, product, lines, variantId, report) => {
   if (!product.sellingPlanGroups?.length || product.productGroupVariants.length) return void 0;
-  for (const variant2 of product.variants) {
+  const modern = typeof product.sellingPlanGroups[0].id !== "number";
+  for (const [index, variant2] of product.variants.entries()) {
     const matched = lines.filter((line) => line.sellingPlanId === void 0 && line.variantId === variant2.id);
     const data = [{ ...product, variants: [variant2] }];
-    if ((variantId === void 0 || variant2.id === variantId) && matched.length === 1 && postPurchaseVariantAvailable(variant2) && projectPostPurchasePlanCatalog({ ...normalized, data })?.plans.length)
-      return { data, line: matched[0] };
+    if ((variantId === void 0 || variant2.id === variantId) && matched.length === 1 && postPurchaseVariantAvailable(variant2)) {
+      const unread = [];
+      if (projectPostPurchasePlanCatalog({ ...normalized, data }, (event) => unread.push(event))?.plans.length)
+        return { data, line: matched[0] };
+      const field = modern && !PostPurchasePlanAllocations.safeParse(variant2.sellingPlanAllocations).success ? `variants.${index}.sellingPlanAllocations` : unread.length ? "sellingPlanGroups" : void 0;
+      if (report && field) reportUnreadableStsLine(product, field, report);
+    }
   }
 };
 var preparePostPurchaseStsView = (widgetId, normalized, product, context, requested, report) => {
   const { originalLineItems } = PostPurchaseStsContext.parse(context);
-  const found = postPurchaseStsLine(normalized, product, originalLineItems, requested.variantId);
+  const found = postPurchaseStsLine(normalized, product, originalLineItems, requested.variantId, report);
   if (!found) return null;
   const whole = found.line.quantity;
   if (requested.quantity !== void 0 && requested.quantity !== whole)
@@ -7984,14 +8020,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 +8034,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) => {
+var classifyPostPurchaseOffer = (settings, response, context, options2, report) => {
+  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 +8071,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)) : [];
+    const stsMembers = sts ? members.filter(({ product }) => postPurchaseStsLine(normalized, product, lines, void 0, report)) : [];
     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/postPurchaseModernPlans.d.ts

@@ -1,4 +1,9 @@
+import { z } from 'zod';
 import { PostPurchasePlanOption } from '../schema/postPurchasePlanCatalog';
+/** A variant's readable `selling_plan_allocations`; a missing list reads as none here, but STS reports it. */
+export declare const PostPurchasePlanAllocations: z.ZodArray<z.ZodObject<{
+    sellingPlanGroupId: z.ZodString;
+}, z.core.$strip>>;
 /**
  * Match allocation groups in product order, then preserve each matching group's plan order. Membership is
  * group-level by design (frozen-branch parity): Shopify allocates every plan of a group to a member variant, and

package/dist/server/postPurchaseResponseDrift.d.ts

@@ -0,0 +1,13 @@
+import type { Reporter, ServerDrift } from '../server/shared';
+/** Records where a parsed product came from, so drift found about it later still names its response and path. */
+export declare const rememberPostPurchaseProductSource: (product: object, response: object, productIndex: number) => void;
+/** The response and raw `productIndex` a parsed product was read from, when it was read by the product source. */
+export declare const postPurchaseProductSourceOf: (product: object) => {
+    productIndex: number;
+    response: object;
+} | undefined;
+/**
+ * Reports each event `report` has not yet heard about `response`, keyed on the `response` object itself: every
+ * projection of one request rereads the same object, so a drift is heard once however many projections find it.
+ */
+export declare const reportOncePerResponse: (response: object, report: Reporter, events: ServerDrift[]) => void;

package/dist/server/postPurchaseSts.d.ts

@@ -18,8 +18,14 @@ export declare const stsAllowed: ({ effective, original }: Pick<Normalized, "eff
  * product is never an STS member; (4) the bound variant is the purchased line's, not the product's selected
  * variant, and subscription is the only mode. The first such variant in catalog order wins, unless `variantId`
  * names one.
+ *
+ * `report` hears a candidate (a purchased, in-stock variant on exactly one one-time line) whose plan data cannot be
+ * read, since it then silently switches nothing: a modern selling-plan variant whose `sellingPlanAllocations` is
+ * missing or malformed, or plan data the catalog cannot read. Each is a `product` drift naming the product id and
+ * the dotted path from the source root, never a value, heard once per response like the source's own drops. A
+ * readable variant that simply has no plan, or no candidate at all, stays silent.
  */
-export declare const postPurchaseStsLine: <T extends Line>(normalized: Normalized, product: Normalized["data"][number], lines: T[], variantId?: number) => {
+export declare const postPurchaseStsLine: <T extends Line>(normalized: Normalized, product: Normalized["data"][number], lines: T[], variantId?: number, report?: Reporter) => {
     data: {
         variants: {
             title: string;

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.57.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.",