@rebuy/rebuy 3.56.0 → 3.56.2

package/dist/index.cjs

@@ -2769,6 +2769,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({

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({

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(".");
@@ -6213,14 +6222,14 @@ var normalizePostPurchaseSource = (settings, response, report) => {
   }
   const effective = PostPurchaseProductSettings.parse((0, import_compat7.merge)({}, original, overrides));
   const data = products.map(({ product }) => product);
-  return { dropped, normalized: { data, effective, metadata, original }, products };
+  const emptiedByDrop = !data.length && dropped.length > 0;
+  return { dropped, normalized: { data, effective, emptiedByDrop, metadata, original }, products };
 };
 var underPostPurchaseCap = (entries, cap) => entries.filter(({ productIndex }) => productIndex < cap);
 var normalizePostPurchaseProduct = (settings, response, report) => {
   const { normalized, products } = normalizePostPurchaseSource(settings, response, report);
-  const { productLimit } = normalized.effective;
-  const readable = productLimit < 1 || underPostPurchaseCap(products, productLimit).length > 0;
-  return readable ? normalized : { ...normalized, data: [] };
+  const capped = normalized.effective.productLimit === 1 && products.length > 0 && !underPostPurchaseCap(products, 1).length;
+  return capped ? { ...normalized, data: [], emptiedByDrop: true } : normalized;
 };
 
 // src/pricing/amountToCents.ts
@@ -6376,6 +6385,7 @@ var readPostPurchaseModernPlans = (raw, allocations) => {
 var projectPostPurchasePlanCatalog = (normalized, report) => {
   const { data } = normalized;
   if (data.length === 1 && data[0].variants.length > 1) return null;
+  if (normalized.emptiedByDrop && !data.length) return null;
   try {
     if (data.length !== 1 || data[0].variants.length !== 1) throw new Error("Ambiguous product");
     const product = data[0];
@@ -6397,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 {
@@ -6950,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");
@@ -8061,7 +8072,7 @@ 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)
+    if (normalized.effective.productType === "one-time" && product.sellingPlanGroups.some((group) => group.requiresSellingPlan))
       throw new Error("Unsupported purchase mode");
     return catalog;
   });

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(".");
@@ -6140,14 +6149,14 @@ var normalizePostPurchaseSource = (settings, response, report) => {
   }
   const effective = PostPurchaseProductSettings.parse(merge({}, original, overrides));
   const data = products.map(({ product }) => product);
-  return { dropped, normalized: { data, effective, metadata, original }, products };
+  const emptiedByDrop = !data.length && dropped.length > 0;
+  return { dropped, normalized: { data, effective, emptiedByDrop, metadata, original }, products };
 };
 var underPostPurchaseCap = (entries, cap) => entries.filter(({ productIndex }) => productIndex < cap);
 var normalizePostPurchaseProduct = (settings, response, report) => {
   const { normalized, products } = normalizePostPurchaseSource(settings, response, report);
-  const { productLimit } = normalized.effective;
-  const readable = productLimit < 1 || underPostPurchaseCap(products, productLimit).length > 0;
-  return readable ? normalized : { ...normalized, data: [] };
+  const capped = normalized.effective.productLimit === 1 && products.length > 0 && !underPostPurchaseCap(products, 1).length;
+  return capped ? { ...normalized, data: [], emptiedByDrop: true } : normalized;
 };
 
 // src/pricing/amountToCents.ts
@@ -6303,6 +6312,7 @@ var readPostPurchaseModernPlans = (raw, allocations) => {
 var projectPostPurchasePlanCatalog = (normalized, report) => {
   const { data } = normalized;
   if (data.length === 1 && data[0].variants.length > 1) return null;
+  if (normalized.emptiedByDrop && !data.length) return null;
   try {
     if (data.length !== 1 || data[0].variants.length !== 1) throw new Error("Ambiguous product");
     const product = data[0];
@@ -6324,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 {
@@ -6877,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");
@@ -7988,7 +7999,7 @@ 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)
+    if (normalized.effective.productType === "one-time" && product.sellingPlanGroups.some((group) => group.requiresSellingPlan))
       throw new Error("Unsupported purchase mode");
     return catalog;
   });

package/dist/server/normalizePostPurchaseCollection.d.ts

@@ -51,6 +51,7 @@ export declare const normalizePostPurchaseCollection: (settings: unknown, respon
             } | undefined;
             metafields?: unknown;
             options?: unknown;
+            requiresSellingPlan?: boolean | null | undefined;
             selectedVariant?: unknown;
         };
         productIndex: number;
@@ -96,6 +97,7 @@ export declare const normalizePostPurchaseCollection: (settings: unknown, respon
             } | undefined;
             metafields?: unknown;
             options?: unknown;
+            requiresSellingPlan?: boolean | null | undefined;
             selectedVariant?: unknown;
         }[];
         effective: {
@@ -175,6 +177,7 @@ export declare const normalizePostPurchaseCollection: (settings: unknown, respon
             subscriptionIsDefault?: boolean | undefined;
             blocks?: unknown[] | undefined;
         };
+        emptiedByDrop: boolean;
         metadata: {
             widget: Record<string, unknown>;
         };

package/dist/server/normalizePostPurchaseProduct.d.ts

@@ -3,7 +3,8 @@ import type { Reporter } from '../server/shared';
 /**
  * The normalized read plus each surviving product's raw `productIndex`, which a collection publishes as member
  * identity. `data` holds only the products the shared schema accepts; `report` hears each dropped one as drift.
- * `dropped` is each rejected product's raw `productIndex` and zod issues.
+ * `dropped` is each rejected product's raw `productIndex` and zod issues. `emptiedByDrop` marks a `data` left
+ * empty only because its products were dropped (and so already reported), not because the source had none.
  */
 export declare const normalizePostPurchaseSource: (settings: unknown, response: unknown, report?: Reporter) => {
     dropped: {
@@ -51,6 +52,7 @@ export declare const normalizePostPurchaseSource: (settings: unknown, response:
             } | undefined;
             metafields?: unknown;
             options?: unknown;
+            requiresSellingPlan?: boolean | null | undefined;
             selectedVariant?: unknown;
         }[];
         effective: {
@@ -130,6 +132,7 @@ export declare const normalizePostPurchaseSource: (settings: unknown, response:
             subscriptionIsDefault?: boolean | undefined;
             blocks?: unknown[] | undefined;
         };
+        emptiedByDrop: boolean;
         metadata: {
             widget: Record<string, unknown>;
         };
@@ -252,6 +255,7 @@ export declare const normalizePostPurchaseSource: (settings: unknown, response:
             } | undefined;
             metafields?: unknown;
             options?: unknown;
+            requiresSellingPlan?: boolean | null | undefined;
             selectedVariant?: unknown;
         };
         productIndex: number;
@@ -270,8 +274,9 @@ export declare const underPostPurchaseCap: <T extends {
  * is empty (as the collection keeps no member), so `[bad, good]` with a limit of 1 prepares nothing. Otherwise
  * `data` keeps every survivor, so a source with more than one readable product still reads as ambiguous rather
  * than having products discarded. Each dropped product, past the cap or not, was already reported as drift.
- * A limit under 1 is a configuration fault, not a cap: `data` stays whole so eligibility rejects it with the
- * configuration reason instead of the catalog reporting drift for a readable product.
+ * Only a limit of exactly 1 caps: any other limit (0, negative, fractional, or above 1) is a configuration
+ * the standalone path refuses anyway, so `data` stays whole and eligibility rejects it with the configuration
+ * reason instead of the catalog reporting drift for a readable product.
  */
 export declare const normalizePostPurchaseProduct: (settings: unknown, response: unknown, report?: Reporter) => {
     data: {
@@ -314,6 +319,7 @@ export declare const normalizePostPurchaseProduct: (settings: unknown, response:
         } | undefined;
         metafields?: unknown;
         options?: unknown;
+        requiresSellingPlan?: boolean | null | undefined;
         selectedVariant?: unknown;
     }[];
     effective: {
@@ -393,6 +399,7 @@ export declare const normalizePostPurchaseProduct: (settings: unknown, response:
         subscriptionIsDefault?: boolean | undefined;
         blocks?: unknown[] | undefined;
     };
+    emptiedByDrop: boolean;
     metadata: {
         widget: Record<string, unknown>;
     };

package/dist/server/postPurchasePlanCatalog.d.ts

@@ -8,6 +8,7 @@ import type { Reporter } from '../server/shared';
  * A catalog binds to exactly one variant, so callers that need plans narrow the product to the chosen variant first.
  * A single product with several variants is a normal unnarrowed shape: it answers null without a drift report. Only
  * genuinely malformed merchandise (no products, several products, no variants, a foreign variant) or unreadable plan
- * data reports `Unreadable post-purchase plan catalog`.
+ * data reports `Unreadable post-purchase plan catalog`. No products because every one under the cap was dropped is
+ * not a second fault: each drop was already reported, so it answers null without another report.
  */
 export declare const projectPostPurchasePlanCatalog: (normalized: ReturnType<typeof normalizePostPurchaseProduct>, report?: Reporter) => PostPurchasePlanCatalog | null;

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/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: {
@@ -730,6 +731,7 @@ export declare const prepareMember: (widgetId: number, settings: unknown, respon
             subscriptionIsDefault?: boolean | undefined;
             blocks?: unknown[] | undefined;
         };
+        emptiedByDrop: boolean;
         metadata: {
             widget: Record<string, unknown>;
         };
@@ -1467,6 +1469,7 @@ export declare const prepareMember: (widgetId: number, settings: unknown, respon
             } | undefined;
             metafields?: unknown;
             options?: unknown;
+            requiresSellingPlan?: boolean | null | undefined;
             selectedVariant?: unknown;
         }[];
         effective: {
@@ -1546,6 +1549,7 @@ export declare const prepareMember: (widgetId: number, settings: unknown, respon
             subscriptionIsDefault?: boolean | undefined;
             blocks?: unknown[] | undefined;
         };
+        emptiedByDrop: boolean;
         metadata: {
             widget: Record<string, unknown>;
         };

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: {
@@ -735,6 +736,7 @@ export declare const preparePostPurchaseStsMember: (widgetId: number, settings:
             subscriptionIsDefault?: boolean | undefined;
             blocks?: unknown[] | undefined;
         };
+        emptiedByDrop: boolean;
         metadata: {
             widget: Record<string, unknown>;
         };

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.0",
+    "version": "3.56.2",
     "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.",