@rebuy/rebuy 3.48.1 → 3.50.0

package/dist/index.cjs

@@ -283,6 +283,7 @@ __export(src_exports, {
   RebuyMonetizeV1: () => RebuyMonetizeV1,
   RecordedOfferDeclineSchema: () => RecordedOfferDeclineSchema,
   RecordedPurchaseObservationSchema: () => RecordedPurchaseObservationSchema,
+  RecoveredFollowupsSchema: () => RecoveredFollowupsSchema,
   ReleaseAuthorityRequestSchema: () => ReleaseAuthorityRequestSchema,
   ReleaseAuthorityResponseSchema: () => ReleaseAuthorityResponseSchema,
   ReleaseClaimRequestSchema: () => ReleaseClaimRequestSchema,
@@ -2903,6 +2904,7 @@ var PostPurchaseProductChangeset = import_zod23.z.object({
 // src/schema/postPurchaseAdmission.ts
 var PurchaseAdmissionModeSchema = import_zod24.z.enum(["purchase", "upgrade"]);
 var selection = PreparedPostPurchaseProduct.shape.selection;
+var EventCalculationSchema = PostPurchaseProductCosts.pick({ currencyCode: true, totalMinor: true }).strict();
 var PurchaseExpectedSchema = import_zod24.z.object({
   buyerConsentToSubscriptions: import_zod24.z.boolean().optional(),
   changeset: PostPurchaseProductChangeset.extend({
@@ -2912,6 +2914,11 @@ var PurchaseExpectedSchema = import_zod24.z.object({
   member: PostPurchaseMemberIdentity.optional(),
   mode: PurchaseAdmissionModeSchema.optional(),
   progressRevision: import_zod24.z.number().int().nonnegative().optional(),
+  /**
+   * The total the buyer affirmed, stored with the admitted operation so a reloaded client can still
+   * send its follow-ups with it. Optional: a client from before it was added admits without one.
+   */
+  reportedCalculation: EventCalculationSchema.optional(),
   selection
 }).refine(
   ({ member, progressRevision }) => !member || progressRevision !== void 0,
@@ -2948,7 +2955,6 @@ var PurchaseReceiptSchema = import_zod24.z.object({
 var PurchaseResponseSchema = import_zod24.z.object({ data: PurchaseReceiptSchema, successful: import_zod24.z.literal(true) });
 
 // src/schema/postPurchaseAcceptedEvent.ts
-var EventCalculationSchema = PostPurchaseProductCosts.pick({ currencyCode: true, totalMinor: true }).strict();
 var AcceptedEventOutcomeSchema = import_zod25.z.enum(["acknowledged", "rejected", "skipped", "unknown"]);
 var AttemptProgressSchema = import_zod25.z.strictObject({
   attemptedAt: PostPurchaseTimestampSchema,
@@ -4835,17 +4841,38 @@ var PostPurchaseProductSettings = PostPurchaseSettings.pick({
 
 // src/schema/postPurchaseRecovery.ts
 var import_zod83 = require("zod");
+var RecoveredFollowupsSchema = import_zod83.z.strictObject({
+  acceptedEvent: import_zod83.z.union([AcceptedEventAttemptProgressSchema, AcceptedEventResultProgressSchema]).nullable(),
+  acceptedMetafield: import_zod83.z.union([AcceptedMetafieldOutcomeSchema, import_zod83.z.literal("attempted")]).nullable()
+});
 var PurchaseRecoveryRequestSchema = DecideRequestSchema.strict();
 var PurchaseRecoveryResponseSchema = import_zod83.z.object({
   data: import_zod83.z.object({
+    /**
+     * Strict, so a client pinned before a new optional field rejects a reply that carries it rather than
+     * stripping it. Release the client before rebuy-api starts emitting a field added here.
+     */
     operation: import_zod83.z.object({
+      /** Absent from a rebuy-api that predates it. */
+      followups: RecoveredFollowupsSchema.optional(),
       observation: RecordedPurchaseObservationSchema.nullable(),
       operationId: PurchaseReceiptSchema.shape.operationId,
+      /** The total the buyer affirmed at admission; absent for an operation admitted without one. */
+      reportedCalculation: EventCalculationSchema.optional(),
       upgrade: UpgradeProgressSchema.optional()
     }).strict().refine(({ operationId, upgrade }) => !upgrade || upgrade.operationId === operationId, {
       message: "Upgrade progress belongs to its operation",
       path: ["upgrade", "operationId"]
-    }).nullable(),
+    }).refine(
+      ({ followups, operationId }) => !followups?.acceptedEvent || followups.acceptedEvent.operationId === operationId,
+      { message: "Follow-up progress belongs to its operation", path: ["followups", "acceptedEvent"] }
+    ).refine(
+      ({ followups, reportedCalculation }) => !followups?.acceptedEvent || !reportedCalculation || followups.acceptedEvent.reportedCalculation.currencyCode === reportedCalculation.currencyCode && followups.acceptedEvent.reportedCalculation.totalMinor === reportedCalculation.totalMinor,
+      {
+        message: "Follow-up progress carries the admitted calculation",
+        path: ["followups", "acceptedEvent", "reportedCalculation"]
+      }
+    ).nullable(),
     progress: PostPurchaseProgressSchema.nullable().optional()
   }),
   successful: import_zod83.z.literal(true)

package/dist/index.mjs

@@ -2432,6 +2432,7 @@ var PostPurchaseProductChangeset = z23.object({
 // src/schema/postPurchaseAdmission.ts
 var PurchaseAdmissionModeSchema = z24.enum(["purchase", "upgrade"]);
 var selection = PreparedPostPurchaseProduct.shape.selection;
+var EventCalculationSchema = PostPurchaseProductCosts.pick({ currencyCode: true, totalMinor: true }).strict();
 var PurchaseExpectedSchema = z24.object({
   buyerConsentToSubscriptions: z24.boolean().optional(),
   changeset: PostPurchaseProductChangeset.extend({
@@ -2441,6 +2442,11 @@ var PurchaseExpectedSchema = z24.object({
   member: PostPurchaseMemberIdentity.optional(),
   mode: PurchaseAdmissionModeSchema.optional(),
   progressRevision: z24.number().int().nonnegative().optional(),
+  /**
+   * The total the buyer affirmed, stored with the admitted operation so a reloaded client can still
+   * send its follow-ups with it. Optional: a client from before it was added admits without one.
+   */
+  reportedCalculation: EventCalculationSchema.optional(),
   selection
 }).refine(
   ({ member, progressRevision }) => !member || progressRevision !== void 0,
@@ -2477,7 +2483,6 @@ var PurchaseReceiptSchema = z24.object({
 var PurchaseResponseSchema = z24.object({ data: PurchaseReceiptSchema, successful: z24.literal(true) });
 
 // src/schema/postPurchaseAcceptedEvent.ts
-var EventCalculationSchema = PostPurchaseProductCosts.pick({ currencyCode: true, totalMinor: true }).strict();
 var AcceptedEventOutcomeSchema = z25.enum(["acknowledged", "rejected", "skipped", "unknown"]);
 var AttemptProgressSchema = z25.strictObject({
   attemptedAt: PostPurchaseTimestampSchema,
@@ -4364,17 +4369,38 @@ var PostPurchaseProductSettings = PostPurchaseSettings.pick({
 
 // src/schema/postPurchaseRecovery.ts
 import { z as z83 } from "zod";
+var RecoveredFollowupsSchema = z83.strictObject({
+  acceptedEvent: z83.union([AcceptedEventAttemptProgressSchema, AcceptedEventResultProgressSchema]).nullable(),
+  acceptedMetafield: z83.union([AcceptedMetafieldOutcomeSchema, z83.literal("attempted")]).nullable()
+});
 var PurchaseRecoveryRequestSchema = DecideRequestSchema.strict();
 var PurchaseRecoveryResponseSchema = z83.object({
   data: z83.object({
+    /**
+     * Strict, so a client pinned before a new optional field rejects a reply that carries it rather than
+     * stripping it. Release the client before rebuy-api starts emitting a field added here.
+     */
     operation: z83.object({
+      /** Absent from a rebuy-api that predates it. */
+      followups: RecoveredFollowupsSchema.optional(),
       observation: RecordedPurchaseObservationSchema.nullable(),
       operationId: PurchaseReceiptSchema.shape.operationId,
+      /** The total the buyer affirmed at admission; absent for an operation admitted without one. */
+      reportedCalculation: EventCalculationSchema.optional(),
       upgrade: UpgradeProgressSchema.optional()
     }).strict().refine(({ operationId, upgrade }) => !upgrade || upgrade.operationId === operationId, {
       message: "Upgrade progress belongs to its operation",
       path: ["upgrade", "operationId"]
-    }).nullable(),
+    }).refine(
+      ({ followups, operationId }) => !followups?.acceptedEvent || followups.acceptedEvent.operationId === operationId,
+      { message: "Follow-up progress belongs to its operation", path: ["followups", "acceptedEvent"] }
+    ).refine(
+      ({ followups, reportedCalculation }) => !followups?.acceptedEvent || !reportedCalculation || followups.acceptedEvent.reportedCalculation.currencyCode === reportedCalculation.currencyCode && followups.acceptedEvent.reportedCalculation.totalMinor === reportedCalculation.totalMinor,
+      {
+        message: "Follow-up progress carries the admitted calculation",
+        path: ["followups", "acceptedEvent", "reportedCalculation"]
+      }
+    ).nullable(),
     progress: PostPurchaseProgressSchema.nullable().optional()
   }),
   successful: z83.literal(true)
@@ -6762,6 +6788,7 @@ export {
   RebuyMonetizeV1,
   RecordedOfferDeclineSchema,
   RecordedPurchaseObservationSchema,
+  RecoveredFollowupsSchema,
   ReleaseAuthorityRequestSchema,
   ReleaseAuthorityResponseSchema,
   ReleaseClaimRequestSchema,

package/dist/schema/postPurchaseAcceptedEvent.d.ts

@@ -1,8 +1,4 @@
 import { z } from 'zod';
-export declare const EventCalculationSchema: z.ZodObject<{
-    currencyCode: z.ZodString;
-    totalMinor: z.ZodNumber;
-}, z.core.$strict>;
 /**
  * apiv2's Flow-trigger bridge outcome, shared by every Flow event (accepted, declined, lifecycle, classification).
  * `skipped` is terminal and intended: apiv2 skips guest orders, whose null customer Flow would refuse.
@@ -72,5 +68,4 @@ export declare const AcceptedEventResponseSchema: z.ZodObject<{
     }, z.core.$strict>]>;
     successful: z.ZodLiteral<true>;
 }, z.core.$strip>;
-export type EventCalculation = z.infer<typeof EventCalculationSchema>;
 export type AcceptedEventOutcome = z.infer<typeof AcceptedEventOutcomeSchema>;

package/dist/schema/postPurchaseAdmission.d.ts

@@ -7,6 +7,11 @@ export declare const PurchaseAdmissionModeSchema: z.ZodEnum<{
     purchase: "purchase";
     upgrade: "upgrade";
 }>;
+/** The buyer's SDK-calculated total for the affirmed terms (`calculateChangeset`), never proof of payment. */
+export declare const EventCalculationSchema: z.ZodObject<{
+    currencyCode: z.ZodString;
+    totalMinor: z.ZodNumber;
+}, z.core.$strict>;
 export declare const PurchaseExpectedSchema: z.ZodObject<{
     buyerConsentToSubscriptions: z.ZodOptional<z.ZodBoolean>;
     changeset: z.ZodObject<{
@@ -65,6 +70,10 @@ export declare const PurchaseExpectedSchema: z.ZodObject<{
         upgrade: "upgrade";
     }>>;
     progressRevision: z.ZodOptional<z.ZodNumber>;
+    reportedCalculation: z.ZodOptional<z.ZodObject<{
+        currencyCode: z.ZodString;
+        totalMinor: z.ZodNumber;
+    }, z.core.$strict>>;
     selection: z.ZodObject<{
         productId: z.ZodNumber;
         quantity: z.ZodNumber;
@@ -133,6 +142,10 @@ export declare const PurchaseRequestSchema: z.ZodObject<{
             upgrade: "upgrade";
         }>>;
         progressRevision: z.ZodOptional<z.ZodNumber>;
+        reportedCalculation: z.ZodOptional<z.ZodObject<{
+            currencyCode: z.ZodString;
+            totalMinor: z.ZodNumber;
+        }, z.core.$strict>>;
         selection: z.ZodObject<{
             productId: z.ZodNumber;
             quantity: z.ZodNumber;
@@ -185,6 +198,7 @@ export declare const PurchaseResponseSchema: z.ZodObject<{
     }, z.core.$strip>;
     successful: z.ZodLiteral<true>;
 }, z.core.$strip>;
+export type EventCalculation = z.infer<typeof EventCalculationSchema>;
 export type PurchaseReceipt = z.infer<typeof PurchaseReceiptSchema>;
 export type PurchaseExpected = z.infer<typeof PurchaseExpectedSchema>;
 export type PurchaseRequest = z.infer<typeof PurchaseRequestSchema>;

package/dist/schema/postPurchaseRecovery.d.ts

@@ -1,4 +1,39 @@
 import { z } from 'zod';
+/**
+ * How far the latest operation's follow-ups got: its accepted Flow event (`null` until one is attempted) and
+ * the status of the saved accepted-metafield write that covers it (`null` until one does). Progress only: a
+ * reloaded client re-runs `/purchases/accepted`, which is idempotent per operation, whatever this says.
+ */
+export declare const RecoveredFollowupsSchema: z.ZodObject<{
+    acceptedEvent: z.ZodNullable<z.ZodUnion<readonly [z.ZodObject<{
+        attemptedAt: z.ZodNumber;
+        reportedCalculation: z.ZodObject<{
+            currencyCode: z.ZodString;
+            totalMinor: z.ZodNumber;
+        }, z.core.$strict>;
+        status: z.ZodLiteral<"attempted">;
+        operationId: z.ZodUUID;
+    }, z.core.$strict>, z.ZodObject<{
+        attemptedAt: z.ZodNumber;
+        reportedCalculation: z.ZodObject<{
+            currencyCode: z.ZodString;
+            totalMinor: z.ZodNumber;
+        }, z.core.$strict>;
+        finishedAt: z.ZodNumber;
+        status: z.ZodEnum<{
+            unknown: "unknown";
+            acknowledged: "acknowledged";
+            rejected: "rejected";
+            skipped: "skipped";
+        }>;
+        operationId: z.ZodUUID;
+    }, z.core.$strict>]>>;
+    acceptedMetafield: z.ZodNullable<z.ZodUnion<readonly [z.ZodEnum<{
+        unknown: "unknown";
+        acknowledged: "acknowledged";
+        rejected: "rejected";
+    }>, z.ZodLiteral<"attempted">]>>;
+}, z.core.$strict>;
 /** A saved observation or its absence, never permission to apply a changeset. */
 export declare const PurchaseRecoveryRequestSchema: z.ZodObject<{
     checkoutToken: z.ZodString;
@@ -7,6 +42,36 @@ export declare const PurchaseRecoveryRequestSchema: z.ZodObject<{
 export declare const PurchaseRecoveryResponseSchema: z.ZodObject<{
     data: z.ZodObject<{
         operation: z.ZodNullable<z.ZodObject<{
+            followups: z.ZodOptional<z.ZodObject<{
+                acceptedEvent: z.ZodNullable<z.ZodUnion<readonly [z.ZodObject<{
+                    attemptedAt: z.ZodNumber;
+                    reportedCalculation: z.ZodObject<{
+                        currencyCode: z.ZodString;
+                        totalMinor: z.ZodNumber;
+                    }, z.core.$strict>;
+                    status: z.ZodLiteral<"attempted">;
+                    operationId: z.ZodUUID;
+                }, z.core.$strict>, z.ZodObject<{
+                    attemptedAt: z.ZodNumber;
+                    reportedCalculation: z.ZodObject<{
+                        currencyCode: z.ZodString;
+                        totalMinor: z.ZodNumber;
+                    }, z.core.$strict>;
+                    finishedAt: z.ZodNumber;
+                    status: z.ZodEnum<{
+                        unknown: "unknown";
+                        acknowledged: "acknowledged";
+                        rejected: "rejected";
+                        skipped: "skipped";
+                    }>;
+                    operationId: z.ZodUUID;
+                }, z.core.$strict>]>>;
+                acceptedMetafield: z.ZodNullable<z.ZodUnion<readonly [z.ZodEnum<{
+                    unknown: "unknown";
+                    acknowledged: "acknowledged";
+                    rejected: "rejected";
+                }>, z.ZodLiteral<"attempted">]>>;
+            }, z.core.$strict>>;
             observation: z.ZodNullable<z.ZodObject<{
                 observation: z.ZodUnion<readonly [z.ZodObject<{
                     changesetApplicationsRemaining: z.ZodNumber;
@@ -39,6 +104,10 @@ export declare const PurchaseRecoveryResponseSchema: z.ZodObject<{
                 recordedAt: z.ZodNumber;
             }, z.core.$strict>>;
             operationId: z.ZodUUID;
+            reportedCalculation: z.ZodOptional<z.ZodObject<{
+                currencyCode: z.ZodString;
+                totalMinor: z.ZodNumber;
+            }, z.core.$strict>>;
             upgrade: z.ZodOptional<z.ZodObject<{
                 compensation: z.ZodNullable<z.ZodUnion<readonly [z.ZodObject<{
                     attemptedAt: z.ZodNumber;
@@ -130,3 +199,5 @@ export declare const PurchaseRecoveryResponseSchema: z.ZodObject<{
     }, z.core.$strip>;
     successful: z.ZodLiteral<true>;
 }, z.core.$strip>;
+export type RecoveredFollowups = z.infer<typeof RecoveredFollowupsSchema>;
+export type PurchaseRecoveryResponse = z.infer<typeof PurchaseRecoveryResponseSchema>;

package/dist/server/index.cjs

@@ -6635,45 +6635,76 @@ var projectPostPurchaseProductDisplay = (effective, metadata, product) => PostPu
 });
 
 // src/server/postPurchaseReviewData.ts
-var import_zod63 = require("zod");
+var import_zod64 = require("zod");
 
 // src/server/postPurchaseJudgeMeReviews.ts
+var import_zod61 = require("zod");
+
+// src/server/postPurchaseReviewFields.ts
 var import_zod60 = require("zod");
+var Field = import_zod60.z.object({ key: import_zod60.z.string(), namespace: import_zod60.z.string(), value: import_zod60.z.unknown().optional() });
+var reviewFields = (raw) => {
+  const fields4 = import_zod60.z.array(import_zod60.z.unknown()).parse(raw).flatMap((field) => {
+    const parsed = Field.safeParse(field);
+    return parsed.success ? [parsed.data] : [];
+  });
+  return (namespace, key) => fields4.find((field) => field.namespace === namespace && field.key === key);
+};
+var ReviewFieldError = class extends Error {
+  constructor(field) {
+    super(`Unreadable review field ${field}`);
+    this.field = field;
+  }
+};
+var readReviewField = (field, read) => {
+  try {
+    return read(field.value);
+  } catch {
+    throw new ReviewFieldError(`${field.namespace}.${field.key}`);
+  }
+};
+
+// src/server/postPurchaseJudgeMeReviews.ts
 var readJudgeMeReviews = (find) => {
   const field = find("judgeme", "badge");
   if (!field) return null;
-  const html = import_zod60.z.string().parse(field.value);
-  const rating = html.match(/data-average-rating=['"](\d+(?:\.\d+)?)['"]/);
-  const count = html.match(/data-number-of-reviews=['"](\d+)['"]/);
-  if (!rating || !count) throw new Error("Unreadable Judge.me attributes");
-  return {
-    rating: PostPurchaseCommonReviewRating.parse({ value: rating[1] }).value,
-    reviewCount: PostPurchaseReviewCount.parse(count[1])
-  };
+  return readReviewField(field, (value) => {
+    const html = import_zod61.z.string().parse(value);
+    const rating = html.match(/data-average-rating=['"](\d+(?:\.\d+)?)['"]/);
+    const count = html.match(/data-number-of-reviews=['"](\d+)['"]/);
+    if (!rating || !count) throw new Error("Unreadable Judge.me attributes");
+    return {
+      rating: PostPurchaseCommonReviewRating.parse({ value: rating[1] }).value,
+      reviewCount: PostPurchaseReviewCount.parse(count[1])
+    };
+  });
 };
 
 // src/server/postPurchaseOkendoReviews.ts
-var import_zod61 = require("zod");
-var Summary = import_zod61.z.object({
+var import_zod62 = require("zod");
+var Summary = import_zod62.z.object({
   reviewAverageValue: PostPurchaseCommonReviewRating.shape.value,
-  reviewCount: import_zod61.z.union([PostPurchaseProductReviews.shape.reviewCount, PostPurchaseReviewCount])
+  reviewCount: import_zod62.z.union([PostPurchaseProductReviews.shape.reviewCount, PostPurchaseReviewCount])
 });
 var readOkendoReviews = (find) => {
   const field = find("okendo", "summaryData");
   if (!field) return null;
-  const summary = Summary.parse(JSON.parse(import_zod61.z.string().parse(field.value)));
+  const summary = readReviewField(field, (value) => Summary.parse(JSON.parse(import_zod62.z.string().parse(value))));
   return { rating: summary.reviewAverageValue, reviewCount: summary.reviewCount };
 };
 
 // src/server/postPurchaseScalarReviews.ts
-var import_zod62 = require("zod");
+var import_zod63 = require("zod");
 var readScalarReviews = (find, namespace, ratingKey, countKey) => {
   const rating = find(namespace, ratingKey);
   const count = find(namespace, countKey);
   if (!rating || !count) return null;
   return {
-    rating: PostPurchaseCommonReviewRating.parse({ value: import_zod62.z.string().parse(rating.value) }).value,
-    reviewCount: PostPurchaseReviewCount.parse(count.value)
+    rating: readReviewField(
+      rating,
+      (value) => PostPurchaseCommonReviewRating.parse({ value: import_zod63.z.string().parse(value) }).value
+    ),
+    reviewCount: readReviewField(count, (value) => PostPurchaseReviewCount.parse(value))
   };
 };
 
@@ -6682,10 +6713,12 @@ var readStandardReviews = (find) => {
   const rating = find("reviews", "rating");
   const count = find("reviews", "rating_count");
   if (!rating || !count) return null;
-  const value = import_zod63.z.string().parse(rating.value);
   return {
-    rating: PostPurchaseCommonReviewRating.parse(/^\d+(?:\.\d+)?$/.test(value) ? { value } : JSON.parse(value)).value,
-    reviewCount: PostPurchaseReviewCount.parse(count.value)
+    rating: readReviewField(rating, (raw) => {
+      const value = import_zod64.z.string().parse(raw);
+      return PostPurchaseCommonReviewRating.parse(/^\d+(?:\.\d+)?$/.test(value) ? { value } : JSON.parse(value)).value;
+    }),
+    reviewCount: readReviewField(count, (value) => PostPurchaseReviewCount.parse(value))
   };
 };
 var readPostPurchaseReviewData = (provider, find) => {
@@ -6702,22 +6735,14 @@ var readPostPurchaseReviewData = (provider, find) => {
   const count = find("reviews", "rating_count");
   if (!rating || !count) return null;
   return {
-    rating: PostPurchaseKlaviyoReviewRating.parse(JSON.parse(import_zod63.z.string().parse(rating.value))).value,
-    reviewCount: PostPurchaseReviewCount.parse(count.value)
+    rating: readReviewField(
+      rating,
+      (value) => PostPurchaseKlaviyoReviewRating.parse(JSON.parse(import_zod64.z.string().parse(value))).value
+    ),
+    reviewCount: readReviewField(count, (value) => PostPurchaseReviewCount.parse(value))
   };
 };
 
-// src/server/postPurchaseReviewFields.ts
-var import_zod64 = require("zod");
-var Field = import_zod64.z.object({ key: import_zod64.z.string(), namespace: import_zod64.z.string(), value: import_zod64.z.unknown().optional() });
-var reviewFields = (raw) => {
-  const fields4 = import_zod64.z.array(import_zod64.z.unknown()).parse(raw).flatMap((field) => {
-    const parsed = Field.safeParse(field);
-    return parsed.success ? [parsed.data] : [];
-  });
-  return (namespace, key) => fields4.find((field) => field.namespace === namespace && field.key === key);
-};
-
 // src/server/postPurchaseReviewProvider.ts
 var import_zod65 = require("zod");
 var IntegrationInput = import_zod65.z.record(import_zod65.z.string(), import_zod65.z.unknown()).prefault({});
@@ -6750,7 +6775,7 @@ var selectPostPurchaseReviewProvider = (raw) => {
 };
 
 // src/server/postPurchaseReviews.ts
-var projectPostPurchaseReviews = (settings, metafields, report) => {
+var projectPostPurchaseReviews = (settings, { id: productId2, metafields }, report) => {
   try {
     const provider = selectPostPurchaseReviewProvider(settings.integrations);
     if (!provider || metafields == null) return null;
@@ -6766,8 +6791,15 @@ var projectPostPurchaseReviews = (settings, metafields, report) => {
       strokeColor: styles2.starStrokeColor,
       strokeWidth: styles2.strokeWidth
     });
-  } catch {
-    report?.({ detail: "Unreadable post-purchase reviews", kind: "product" });
+  } catch (error) {
+    report?.(
+      error instanceof ReviewFieldError ? {
+        detail: "Unreadable post-purchase reviews metafield",
+        field: error.field,
+        kind: "reviews",
+        productId: productId2
+      } : { detail: "Unreadable post-purchase reviews", kind: "product" }
+    );
     return null;
   }
 };
@@ -6779,7 +6811,7 @@ var projectPostPurchaseProduct = ({ data, effective, metadata, original }, repor
   return {
     display: {
       ...projectPostPurchaseProductDisplay(effective, metadata, product),
-      reviews: projectPostPurchaseReviews(effective, product.metafields, report)
+      reviews: projectPostPurchaseReviews(effective, product, report)
     },
     labels: effective.language.global,
     product: { ...product, variant: variant2 },
@@ -7225,6 +7257,7 @@ var PostPurchaseMemberIdentity = import_zod75.z.object({
 // src/schema/postPurchaseAdmission.ts
 var PurchaseAdmissionModeSchema = import_zod76.z.enum(["purchase", "upgrade"]);
 var selection = PreparedPostPurchaseProduct.shape.selection;
+var EventCalculationSchema = PostPurchaseProductCosts.pick({ currencyCode: true, totalMinor: true }).strict();
 var PurchaseExpectedSchema = import_zod76.z.object({
   buyerConsentToSubscriptions: import_zod76.z.boolean().optional(),
   changeset: PostPurchaseProductChangeset.extend({
@@ -7234,6 +7267,11 @@ var PurchaseExpectedSchema = import_zod76.z.object({
   member: PostPurchaseMemberIdentity.optional(),
   mode: PurchaseAdmissionModeSchema.optional(),
   progressRevision: import_zod76.z.number().int().nonnegative().optional(),
+  /**
+   * The total the buyer affirmed, stored with the admitted operation so a reloaded client can still
+   * send its follow-ups with it. Optional: a client from before it was added admits without one.
+   */
+  reportedCalculation: EventCalculationSchema.optional(),
   selection
 }).refine(
   ({ member, progressRevision }) => !member || progressRevision !== void 0,
@@ -7270,7 +7308,6 @@ var PurchaseReceiptSchema = import_zod76.z.object({
 var PurchaseResponseSchema = import_zod76.z.object({ data: PurchaseReceiptSchema, successful: import_zod76.z.literal(true) });
 
 // src/schema/postPurchaseAcceptedEvent.ts
-var EventCalculationSchema = PostPurchaseProductCosts.pick({ currencyCode: true, totalMinor: true }).strict();
 var AcceptedEventOutcomeSchema = import_zod77.z.enum(["acknowledged", "rejected", "skipped", "unknown"]);
 var AttemptProgressSchema = import_zod77.z.strictObject({
   attemptedAt: PostPurchaseTimestampSchema,

package/dist/server/index.mjs

@@ -6563,45 +6563,76 @@ var projectPostPurchaseProductDisplay = (effective, metadata, product) => PostPu
 });
 
 // src/server/postPurchaseReviewData.ts
-import { z as z63 } from "zod";
+import { z as z64 } from "zod";
 
 // src/server/postPurchaseJudgeMeReviews.ts
+import { z as z61 } from "zod";
+
+// src/server/postPurchaseReviewFields.ts
 import { z as z60 } from "zod";
+var Field = z60.object({ key: z60.string(), namespace: z60.string(), value: z60.unknown().optional() });
+var reviewFields = (raw) => {
+  const fields4 = z60.array(z60.unknown()).parse(raw).flatMap((field) => {
+    const parsed = Field.safeParse(field);
+    return parsed.success ? [parsed.data] : [];
+  });
+  return (namespace, key) => fields4.find((field) => field.namespace === namespace && field.key === key);
+};
+var ReviewFieldError = class extends Error {
+  constructor(field) {
+    super(`Unreadable review field ${field}`);
+    this.field = field;
+  }
+};
+var readReviewField = (field, read) => {
+  try {
+    return read(field.value);
+  } catch {
+    throw new ReviewFieldError(`${field.namespace}.${field.key}`);
+  }
+};
+
+// src/server/postPurchaseJudgeMeReviews.ts
 var readJudgeMeReviews = (find) => {
   const field = find("judgeme", "badge");
   if (!field) return null;
-  const html = z60.string().parse(field.value);
-  const rating = html.match(/data-average-rating=['"](\d+(?:\.\d+)?)['"]/);
-  const count = html.match(/data-number-of-reviews=['"](\d+)['"]/);
-  if (!rating || !count) throw new Error("Unreadable Judge.me attributes");
-  return {
-    rating: PostPurchaseCommonReviewRating.parse({ value: rating[1] }).value,
-    reviewCount: PostPurchaseReviewCount.parse(count[1])
-  };
+  return readReviewField(field, (value) => {
+    const html = z61.string().parse(value);
+    const rating = html.match(/data-average-rating=['"](\d+(?:\.\d+)?)['"]/);
+    const count = html.match(/data-number-of-reviews=['"](\d+)['"]/);
+    if (!rating || !count) throw new Error("Unreadable Judge.me attributes");
+    return {
+      rating: PostPurchaseCommonReviewRating.parse({ value: rating[1] }).value,
+      reviewCount: PostPurchaseReviewCount.parse(count[1])
+    };
+  });
 };
 
 // src/server/postPurchaseOkendoReviews.ts
-import { z as z61 } from "zod";
-var Summary = z61.object({
+import { z as z62 } from "zod";
+var Summary = z62.object({
   reviewAverageValue: PostPurchaseCommonReviewRating.shape.value,
-  reviewCount: z61.union([PostPurchaseProductReviews.shape.reviewCount, PostPurchaseReviewCount])
+  reviewCount: z62.union([PostPurchaseProductReviews.shape.reviewCount, PostPurchaseReviewCount])
 });
 var readOkendoReviews = (find) => {
   const field = find("okendo", "summaryData");
   if (!field) return null;
-  const summary = Summary.parse(JSON.parse(z61.string().parse(field.value)));
+  const summary = readReviewField(field, (value) => Summary.parse(JSON.parse(z62.string().parse(value))));
   return { rating: summary.reviewAverageValue, reviewCount: summary.reviewCount };
 };
 
 // src/server/postPurchaseScalarReviews.ts
-import { z as z62 } from "zod";
+import { z as z63 } from "zod";
 var readScalarReviews = (find, namespace, ratingKey, countKey) => {
   const rating = find(namespace, ratingKey);
   const count = find(namespace, countKey);
   if (!rating || !count) return null;
   return {
-    rating: PostPurchaseCommonReviewRating.parse({ value: z62.string().parse(rating.value) }).value,
-    reviewCount: PostPurchaseReviewCount.parse(count.value)
+    rating: readReviewField(
+      rating,
+      (value) => PostPurchaseCommonReviewRating.parse({ value: z63.string().parse(value) }).value
+    ),
+    reviewCount: readReviewField(count, (value) => PostPurchaseReviewCount.parse(value))
   };
 };
 
@@ -6610,10 +6641,12 @@ var readStandardReviews = (find) => {
   const rating = find("reviews", "rating");
   const count = find("reviews", "rating_count");
   if (!rating || !count) return null;
-  const value = z63.string().parse(rating.value);
   return {
-    rating: PostPurchaseCommonReviewRating.parse(/^\d+(?:\.\d+)?$/.test(value) ? { value } : JSON.parse(value)).value,
-    reviewCount: PostPurchaseReviewCount.parse(count.value)
+    rating: readReviewField(rating, (raw) => {
+      const value = z64.string().parse(raw);
+      return PostPurchaseCommonReviewRating.parse(/^\d+(?:\.\d+)?$/.test(value) ? { value } : JSON.parse(value)).value;
+    }),
+    reviewCount: readReviewField(count, (value) => PostPurchaseReviewCount.parse(value))
   };
 };
 var readPostPurchaseReviewData = (provider, find) => {
@@ -6630,22 +6663,14 @@ var readPostPurchaseReviewData = (provider, find) => {
   const count = find("reviews", "rating_count");
   if (!rating || !count) return null;
   return {
-    rating: PostPurchaseKlaviyoReviewRating.parse(JSON.parse(z63.string().parse(rating.value))).value,
-    reviewCount: PostPurchaseReviewCount.parse(count.value)
+    rating: readReviewField(
+      rating,
+      (value) => PostPurchaseKlaviyoReviewRating.parse(JSON.parse(z64.string().parse(value))).value
+    ),
+    reviewCount: readReviewField(count, (value) => PostPurchaseReviewCount.parse(value))
   };
 };
 
-// src/server/postPurchaseReviewFields.ts
-import { z as z64 } from "zod";
-var Field = z64.object({ key: z64.string(), namespace: z64.string(), value: z64.unknown().optional() });
-var reviewFields = (raw) => {
-  const fields4 = z64.array(z64.unknown()).parse(raw).flatMap((field) => {
-    const parsed = Field.safeParse(field);
-    return parsed.success ? [parsed.data] : [];
-  });
-  return (namespace, key) => fields4.find((field) => field.namespace === namespace && field.key === key);
-};
-
 // src/server/postPurchaseReviewProvider.ts
 import { z as z65 } from "zod";
 var IntegrationInput = z65.record(z65.string(), z65.unknown()).prefault({});
@@ -6678,7 +6703,7 @@ var selectPostPurchaseReviewProvider = (raw) => {
 };
 
 // src/server/postPurchaseReviews.ts
-var projectPostPurchaseReviews = (settings, metafields, report) => {
+var projectPostPurchaseReviews = (settings, { id: productId2, metafields }, report) => {
   try {
     const provider = selectPostPurchaseReviewProvider(settings.integrations);
     if (!provider || metafields == null) return null;
@@ -6694,8 +6719,15 @@ var projectPostPurchaseReviews = (settings, metafields, report) => {
       strokeColor: styles2.starStrokeColor,
       strokeWidth: styles2.strokeWidth
     });
-  } catch {
-    report?.({ detail: "Unreadable post-purchase reviews", kind: "product" });
+  } catch (error) {
+    report?.(
+      error instanceof ReviewFieldError ? {
+        detail: "Unreadable post-purchase reviews metafield",
+        field: error.field,
+        kind: "reviews",
+        productId: productId2
+      } : { detail: "Unreadable post-purchase reviews", kind: "product" }
+    );
     return null;
   }
 };
@@ -6707,7 +6739,7 @@ var projectPostPurchaseProduct = ({ data, effective, metadata, original }, repor
   return {
     display: {
       ...projectPostPurchaseProductDisplay(effective, metadata, product),
-      reviews: projectPostPurchaseReviews(effective, product.metafields, report)
+      reviews: projectPostPurchaseReviews(effective, product, report)
     },
     labels: effective.language.global,
     product: { ...product, variant: variant2 },
@@ -7153,6 +7185,7 @@ var PostPurchaseMemberIdentity = z75.object({
 // src/schema/postPurchaseAdmission.ts
 var PurchaseAdmissionModeSchema = z76.enum(["purchase", "upgrade"]);
 var selection = PreparedPostPurchaseProduct.shape.selection;
+var EventCalculationSchema = PostPurchaseProductCosts.pick({ currencyCode: true, totalMinor: true }).strict();
 var PurchaseExpectedSchema = z76.object({
   buyerConsentToSubscriptions: z76.boolean().optional(),
   changeset: PostPurchaseProductChangeset.extend({
@@ -7162,6 +7195,11 @@ var PurchaseExpectedSchema = z76.object({
   member: PostPurchaseMemberIdentity.optional(),
   mode: PurchaseAdmissionModeSchema.optional(),
   progressRevision: z76.number().int().nonnegative().optional(),
+  /**
+   * The total the buyer affirmed, stored with the admitted operation so a reloaded client can still
+   * send its follow-ups with it. Optional: a client from before it was added admits without one.
+   */
+  reportedCalculation: EventCalculationSchema.optional(),
   selection
 }).refine(
   ({ member, progressRevision }) => !member || progressRevision !== void 0,
@@ -7198,7 +7236,6 @@ var PurchaseReceiptSchema = z76.object({
 var PurchaseResponseSchema = z76.object({ data: PurchaseReceiptSchema, successful: z76.literal(true) });
 
 // src/schema/postPurchaseAcceptedEvent.ts
-var EventCalculationSchema = PostPurchaseProductCosts.pick({ currencyCode: true, totalMinor: true }).strict();
 var AcceptedEventOutcomeSchema = z77.enum(["acknowledged", "rejected", "skipped", "unknown"]);
 var AttemptProgressSchema = z77.strictObject({
   attemptedAt: PostPurchaseTimestampSchema,

package/dist/server/postPurchaseJudgeMeReviews.d.ts

@@ -1,4 +1,4 @@
-import type { ReviewFields } from '../server/postPurchaseReviewFields';
+import { type ReviewFields } from '../server/postPurchaseReviewFields';
 /** Read attributes only; merchant badge HTML never enters the prepared display or section tree. */
 export declare const readJudgeMeReviews: (find: ReviewFields) => {
     rating: number;

package/dist/server/postPurchaseOkendoReviews.d.ts

@@ -1,4 +1,4 @@
-import type { ReviewFields } from '../server/postPurchaseReviewFields';
+import { type ReviewFields } from '../server/postPurchaseReviewFields';
 /** Only the selected aggregate's two numeric members enter the prepared review display. */
 export declare const readOkendoReviews: (find: ReviewFields) => {
     rating: number;

package/dist/server/postPurchaseReviewData.d.ts

@@ -1,4 +1,4 @@
-import type { ReviewFields } from '../server/postPurchaseReviewFields';
+import { type ReviewFields } from '../server/postPurchaseReviewFields';
 import type { selectPostPurchaseReviewProvider } from '../server/postPurchaseReviewProvider';
 /**
  * Selection is complete before reading data; a missing selected aggregate cannot fall through. Reviews.io reading

package/dist/server/postPurchaseReviewFields.d.ts

@@ -5,3 +5,10 @@ export declare const reviewFields: (raw: unknown) => (namespace: string, key: st
     value?: unknown;
 } | undefined;
 export type ReviewFields = ReturnType<typeof reviewFields>;
+/** A selected review field whose value failed its read. It names the field (`namespace.key`), never the value. */
+export declare class ReviewFieldError extends Error {
+    readonly field: string;
+    constructor(field: string);
+}
+/** Reads one matched field's value; any failure is rethrown naming only that field. */
+export declare const readReviewField: <T>(field: NonNullable<ReturnType<ReviewFields>>, read: (value: unknown) => T) => T;

package/dist/server/postPurchaseReviews.d.ts

@@ -1,5 +1,12 @@
 import { PostPurchaseProductReviews } from '../schema/postPurchaseProductReviews';
 import type { PostPurchaseProductSettings } from '../schema/postPurchaseProductSettings';
 import type { Reporter } from '../server/shared';
-/** Reviews are optional display data; neither missing nor malformed aggregates invalidate the offer. */
-export declare const projectPostPurchaseReviews: (settings: PostPurchaseProductSettings, metafields: unknown, report?: Reporter) => PostPurchaseProductReviews | null;
+/**
+ * Reviews are optional display data; neither missing nor malformed aggregates invalidate the offer. A malformed
+ * selected review field reports `reviews` drift naming the product and the field (`namespace.key`, never the
+ * value); unreadable flags, metafield containers, styles or output stay sanitized `product` drift.
+ */
+export declare const projectPostPurchaseReviews: (settings: PostPurchaseProductSettings, { id: productId, metafields }: {
+    id: number;
+    metafields?: unknown;
+}, report?: Reporter) => PostPurchaseProductReviews | null;

package/dist/server/postPurchaseScalarReviews.d.ts

@@ -1,4 +1,4 @@
-import type { ReviewFields } from '../server/postPurchaseReviewFields';
+import { type ReviewFields } from '../server/postPurchaseReviewFields';
 /** Pair absence is ordinary; invalid selected values throw to the single local recovery boundary. */
 export declare const readScalarReviews: (find: ReviewFields, namespace: string, ratingKey: string, countKey: string) => {
     rating: number;

package/dist/server/shared.d.ts

@@ -28,14 +28,21 @@ export type UpstreamFetch = (path: string, params: Record<string, string>, optio
 /**
  * A drift signal the orchestrators emit when a per-item payload salvage drops something: a malformed
  * offer product, an invalid/unknown section stubbed out, an unreadable rule verdict, a shop-config
- * entry the shared schema inerted (`shopConfig`), or unreadable selectable-gift milestones
- * (`giftMilestones` — the widget's gifts are then kept). Distinct from a hard {@link UpstreamError} — the
+ * entry the shared schema inerted (`shopConfig`), unreadable selectable-gift milestones
+ * (`giftMilestones` — the widget's gifts are then kept), or a post-purchase product's malformed selected review
+ * metafield (`reviews` — the reviews are then omitted; it names the product and the field, never the value). Distinct from a hard {@link UpstreamError} — the
  * request still succeeds (degraded), so this is the only trace that an upstream contract moved. Optional
  * on {@link ServerContext}; the host (rebuy-api) wires it to its logger.
  */
 export type ServerDrift = {
     detail: string;
     kind: 'b2bAvailability' | 'dataSource' | 'giftMilestones' | 'monetizeOffer' | 'product' | 'ruleVerdict' | 'section' | 'shopConfig';
+} | {
+    detail: string;
+    /** The malformed selected review metafield as `namespace.key`; never its value. */
+    field: string;
+    kind: 'reviews';
+    productId: number;
 };
 /** A {@link ServerDrift} sink, as the orchestrators pass it around internally. */
 export type Reporter = (event: ServerDrift) => void;

package/package.json

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