@rebuy/rebuy 3.55.0 → 3.56.1

package/dist/schema/index.d.ts

@@ -21,6 +21,7 @@ export * from './postPurchaseHealth';
 export * from './postPurchaseHealthProgress';
 export * from './postPurchaseHealthSchedule';
 export * from './postPurchaseIdentity';
+export * from './postPurchaseLedger';
 export * from './postPurchaseLifecycle';
 export * from './postPurchaseMemberIdentity';
 export * from './postPurchaseObservation';

package/dist/schema/postPurchaseAdmission.d.ts

@@ -4,8 +4,8 @@ import { z } from 'zod';
  * refunds the buyer's original one-time line of the same variant; the server binds that line, never the client.
  */
 export declare const PurchaseAdmissionModeSchema: z.ZodEnum<{
-    purchase: "purchase";
     sts: "sts";
+    purchase: "purchase";
 }>;
 /** The buyer's SDK-calculated total for the affirmed terms (`calculateChangeset`), never proof of payment. */
 export declare const EventCalculationSchema: z.ZodObject<{
@@ -66,8 +66,8 @@ export declare const PurchaseExpectedSchema: z.ZodObject<{
         productIndex: z.ZodNumber;
     }, z.core.$strict>>;
     mode: z.ZodOptional<z.ZodEnum<{
-        purchase: "purchase";
         sts: "sts";
+        purchase: "purchase";
     }>>;
     progressRevision: z.ZodOptional<z.ZodNumber>;
     reportedCalculation: z.ZodOptional<z.ZodObject<{
@@ -138,8 +138,8 @@ export declare const PurchaseRequestSchema: z.ZodObject<{
             productIndex: z.ZodNumber;
         }, z.core.$strict>>;
         mode: z.ZodOptional<z.ZodEnum<{
-            purchase: "purchase";
             sts: "sts";
+            purchase: "purchase";
         }>>;
         progressRevision: z.ZodOptional<z.ZodNumber>;
         reportedCalculation: z.ZodOptional<z.ZodObject<{
@@ -159,8 +159,8 @@ export declare const PurchaseReceiptSchema: z.ZodObject<{
     admittedAt: z.ZodNumber;
     changesetToken: z.ZodString;
     mode: z.ZodOptional<z.ZodEnum<{
-        purchase: "purchase";
         sts: "sts";
+        purchase: "purchase";
     }>>;
     operationId: z.ZodUUID;
     originalLine: z.ZodOptional<z.ZodObject<{
@@ -180,8 +180,8 @@ export declare const PurchaseResponseSchema: z.ZodObject<{
         admittedAt: z.ZodNumber;
         changesetToken: z.ZodString;
         mode: z.ZodOptional<z.ZodEnum<{
-            purchase: "purchase";
             sts: "sts";
+            purchase: "purchase";
         }>>;
         operationId: z.ZodUUID;
         originalLine: z.ZodOptional<z.ZodObject<{

package/dist/schema/postPurchaseLedger.d.ts

@@ -0,0 +1,56 @@
+import { z } from 'zod';
+/** At most this many rows per `/cab/post-purchase/ledger` request; the client sends one per observation. */
+export declare const CLIENT_LEDGER_MAX_EVENTS = 16;
+/**
+ * The ledger types cab-post-purchase writes, each registered in apiv2's
+ * `LogEventValidationService::EVENT_REGISTRY`. rebuy-api refuses any other type, so the route can never
+ * write a server-owned row (`changeset.*`, `health.*`, `decision.shadow`, …).
+ */
+export declare const CLIENT_LEDGER_TYPES: readonly ["decision.verdict", "error.flow", "error.schema", "offer.decline", "render.gate", "shouldRender.selectedFlow"];
+/** One client-observed ledger row. */
+export declare const ClientLedgerEventSchema: z.ZodObject<{
+    instance: z.ZodString;
+    payload: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+    phase: z.ZodEnum<{
+        render: "render";
+        shouldRender: "shouldRender";
+    }>;
+    seq: z.ZodNumber;
+    ts: z.ZodISODateTime;
+    type: z.ZodEnum<{
+        "decision.verdict": "decision.verdict";
+        "error.flow": "error.flow";
+        "error.schema": "error.schema";
+        "offer.decline": "offer.decline";
+        "render.gate": "render.gate";
+        "shouldRender.selectedFlow": "shouldRender.selectedFlow";
+    }>;
+}, z.core.$strict>;
+/**
+ * A batch of client-observed ledger rows for `/cab/post-purchase/ledger`. Identity (checkout, shop, upstream)
+ * is never read from the body: rebuy-api takes it from the verified post-purchase token, so any echoed
+ * `shop`/`checkoutToken` is stripped.
+ */
+export declare const ClientLedgerRequestSchema: z.ZodObject<{
+    events: z.ZodArray<z.ZodObject<{
+        instance: z.ZodString;
+        payload: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+        phase: z.ZodEnum<{
+            render: "render";
+            shouldRender: "shouldRender";
+        }>;
+        seq: z.ZodNumber;
+        ts: z.ZodISODateTime;
+        type: z.ZodEnum<{
+            "decision.verdict": "decision.verdict";
+            "error.flow": "error.flow";
+            "error.schema": "error.schema";
+            "offer.decline": "offer.decline";
+            "render.gate": "render.gate";
+            "shouldRender.selectedFlow": "shouldRender.selectedFlow";
+        }>;
+    }, z.core.$strict>>;
+}, z.core.$strip>;
+export type ClientLedgerEvent = z.infer<typeof ClientLedgerEventSchema>;
+export type ClientLedgerRequest = z.infer<typeof ClientLedgerRequestSchema>;
+export type ClientLedgerType = (typeof CLIENT_LEDGER_TYPES)[number];

package/dist/schema/postPurchaseProduct.d.ts

@@ -168,6 +168,7 @@ export declare const PreparedPostPurchaseProduct: z.ZodObject<{
                 presentmentTitle: z.ZodString;
                 title: z.ZodString;
             }, z.core.$strip>;
+            sts: z.ZodOptional<z.ZodLiteral<true>>;
         }, z.core.$strip>>;
     }, z.core.$strip>;
 }, z.core.$strip>;
@@ -333,6 +334,7 @@ export declare const PostPurchasePreparation: z.ZodDiscriminatedUnion<[z.ZodObje
                 presentmentTitle: z.ZodString;
                 title: z.ZodString;
             }, z.core.$strip>;
+            sts: z.ZodOptional<z.ZodLiteral<true>>;
         }, z.core.$strip>>;
     }, z.core.$strip>;
 }, z.core.$strip>, z.ZodObject<{

package/dist/schema/postPurchaseProductCollectionView.d.ts

@@ -185,6 +185,7 @@ export declare const PostPurchaseProductCollectionView: z.ZodObject<{
                             presentmentTitle: z.ZodString;
                             title: z.ZodString;
                         }, z.core.$strip>;
+                        sts: z.ZodOptional<z.ZodLiteral<true>>;
                     }, z.core.$strip>>;
                 }, z.core.$strip>;
                 display: z.ZodObject<{
@@ -658,6 +659,7 @@ export declare const PostPurchaseProductCollectionView: z.ZodObject<{
                 version: z.ZodDefault<z.ZodLiteral<2>>;
                 widgetId: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
             }, z.core.$strip>;
+            sts: z.ZodOptional<z.ZodLiteral<true>>;
             variantCatalog: z.ZodOptional<z.ZodObject<{
                 displayMode: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
                     single: "single";
@@ -1121,6 +1123,7 @@ export declare const PostPurchaseProductCollectionView: z.ZodObject<{
                 version: z.ZodDefault<z.ZodLiteral<2>>;
                 widgetId: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
             }, z.core.$strip>>;
+            sts: z.ZodOptional<z.ZodLiteral<true>>;
             variantCatalog: z.ZodOptional<z.ZodObject<{
                 displayMode: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
                     single: "single";

package/dist/schema/postPurchaseProductView.d.ts

@@ -5,7 +5,8 @@ import { z } from 'zod';
  * Only a prepared view may carry `changeset`: the unsigned changeset the server derived from this very
  * preparation (the one admission later rebuilds and signs), ready for Shopify's `calculateChangeset`, and
  * `displayPrice`: the display pricing worked out from that same preparation. `preparation.status` discriminates
- * the two; an unprepared view may carry a tree too.
+ * the two; an unprepared view may carry a tree too. `sts` marks a switch to subscription (STS): the buyer's
+ * own one-time line becomes this subscription, so the renderer must expect the switch (`mode: 'sts'`).
  */
 export declare const PostPurchaseProductView: z.ZodUnion<readonly [z.ZodObject<{
     changeset: z.ZodOptional<z.ZodObject<{
@@ -188,6 +189,7 @@ export declare const PostPurchaseProductView: z.ZodUnion<readonly [z.ZodObject<{
                     presentmentTitle: z.ZodString;
                     title: z.ZodString;
                 }, z.core.$strip>;
+                sts: z.ZodOptional<z.ZodLiteral<true>>;
             }, z.core.$strip>>;
         }, z.core.$strip>;
         display: z.ZodObject<{
@@ -661,6 +663,7 @@ export declare const PostPurchaseProductView: z.ZodUnion<readonly [z.ZodObject<{
         version: z.ZodDefault<z.ZodLiteral<2>>;
         widgetId: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
     }, z.core.$strip>;
+    sts: z.ZodOptional<z.ZodLiteral<true>>;
     variantCatalog: z.ZodOptional<z.ZodObject<{
         displayMode: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
             single: "single";
@@ -1124,6 +1127,7 @@ export declare const PostPurchaseProductView: z.ZodUnion<readonly [z.ZodObject<{
         version: z.ZodDefault<z.ZodLiteral<2>>;
         widgetId: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
     }, z.core.$strip>>;
+    sts: z.ZodOptional<z.ZodLiteral<true>>;
     variantCatalog: z.ZodOptional<z.ZodObject<{
         displayMode: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
             single: "single";

package/dist/schema/postPurchaseSession.d.ts

@@ -106,6 +106,20 @@ export declare const SessionStartResponseSchema: z.ZodObject<{
     }, z.core.$strip>;
     successful: z.ZodLiteral<true>;
 }, z.core.$strip>;
+/**
+ * The `/session/start` 409 (`reason: order-pending`): the order this checkout anchors to is not searchable in
+ * Shopify yet, so a later start can succeed once `Retry-After` seconds pass. rebuy-api's error envelope, so
+ * `errors` and `message` are required here, unlike on a success.
+ */
+export declare const PostPurchaseOrderPendingSchema: z.ZodObject<{
+    errors: z.ZodArray<z.ZodObject<{
+        message: z.ZodString;
+    }, z.core.$strip>>;
+    message: z.ZodString;
+    reason: z.ZodLiteral<"order-pending">;
+    successful: z.ZodLiteral<false>;
+}, z.core.$strip>;
+export type PostPurchaseOrderPending = z.infer<typeof PostPurchaseOrderPendingSchema>;
 export type ReadySessionTiming = z.infer<typeof ReadySessionTimingSchema>;
 export type SessionIdentity = z.infer<typeof SessionIdentitySchema>;
 export type SessionOrderTiming = z.infer<typeof SessionOrderTimingSchema>;

package/dist/schema/postPurchaseSubscription.d.ts

@@ -17,5 +17,6 @@ export declare const PostPurchaseSubscriptionTerms: z.ZodObject<{
         presentmentTitle: z.ZodString;
         title: z.ZodString;
     }, z.core.$strip>;
+    sts: z.ZodOptional<z.ZodLiteral<true>>;
 }, z.core.$strip>;
 export type PostPurchaseSubscriptionTerms = z.infer<typeof PostPurchaseSubscriptionTerms>;

package/dist/schema/postPurchaseSubscriptionProduct.d.ts

@@ -161,6 +161,7 @@ export declare const PreparedPostPurchaseSubscription: z.ZodObject<{
                 presentmentTitle: z.ZodString;
                 title: z.ZodString;
             }, z.core.$strip>;
+            sts: z.ZodOptional<z.ZodLiteral<true>>;
         }, z.core.$strip>;
     }, z.core.$strip>;
 }, z.core.$strip>;
@@ -304,6 +305,7 @@ export declare const readPostPurchaseSubscription: (prepared: z.infer<typeof Pre
                 amount: number;
                 type: "price" | "fixed_amount" | "percentage";
             } | undefined;
+            sts?: true | undefined;
         };
     };
 } | undefined;

package/dist/server/index.cjs

@@ -4644,9 +4644,11 @@ var HAS_RECURRING_TOTAL = "hasRecurringTotal";
 var HAS_RECURRING_SHIPPING = "hasRecurringShipping";
 var small = { color: "subdued", fontSize: "small" };
 var FOOTNOTES = ["Doesn't include tax, duties, or any applicable discounts.", "Auto-renews, skip or cancel anytime"];
+var countsRecurringShipping = ({ productType, upgradeToSubscription }) => productType === "subscription" && upgradeToSubscription.allow;
 var recurringSummary = (settings) => {
   if (!sellsSubscription(settings)) return [];
   const { global: global2 } = settings.language;
+  const shipping = countsRecurringShipping(settings);
   return [
     {
       direction: "rows",
@@ -4657,18 +4659,20 @@ var recurringSummary = (settings) => {
           columns: ["fill", "auto", "auto"],
           label: merchantLabel(global2.recurringSubtotal, "Recurring subtotal"),
           spacing: "extraTight",
-          token: "{{recurringTotal}}",
+          token: shipping ? "{{recurringTotal}}" : "{{recurringSubtotal}}",
           variable: HAS_RECURRING_TOTAL
         }),
-        earnedRow({
-          after: "(included)",
-          columns: ["auto", "auto", "auto"],
-          label: { en: `${merchantLabel(global2.recurringShipping, "Recurring shipping").en}:` },
-          look: small,
-          spacing: "extraTight",
-          token: "{{recurringShipping}}",
-          variable: HAS_RECURRING_SHIPPING
-        }),
+        ...shipping ? [
+          earnedRow({
+            after: "(included)",
+            columns: ["auto", "auto", "auto"],
+            label: { en: `${merchantLabel(global2.recurringShipping, "Recurring shipping").en}:` },
+            look: small,
+            spacing: "extraTight",
+            token: "{{recurringShipping}}",
+            variable: HAS_RECURRING_SHIPPING
+          })
+        ] : [],
         ...FOOTNOTES.map((text2) => ({
           content: { en: styledCopy(text2, small) },
           sectionType: "text",
@@ -4677,7 +4681,9 @@ var recurringSummary = (settings) => {
       ],
       sectionType: "layout",
       spacing: "tight",
-      variables: earnedVariables([HAS_RECURRING_TOTAL, HAS_RECURRING_SHIPPING])
+      variables: earnedVariables(
+        shipping ? [HAS_RECURRING_TOTAL, HAS_RECURRING_SHIPPING] : [HAS_RECURRING_TOTAL]
+      )
     }
   ];
 };
@@ -6207,9 +6213,15 @@ 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 capped = normalized.effective.productLimit === 1 && products.length > 0 && !underPostPurchaseCap(products, 1).length;
+  return capped ? { ...normalized, data: [], emptiedByDrop: true } : normalized;
 };
-var normalizePostPurchaseProduct = (settings, response, report) => normalizePostPurchaseSource(settings, response, report).normalized;
 
 // src/pricing/amountToCents.ts
 var round = (value, precision = 0) => {
@@ -6364,6 +6376,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];
@@ -6482,7 +6495,9 @@ var PostPurchaseSubscriptionTerms = import_zod56.z.object({
   intervalLabel: import_zod56.z.string().min(1),
   name: import_zod56.z.string().min(1),
   recurringShippingPrice: import_zod56.z.number().nonnegative(),
-  shippingOption: import_zod56.z.object({ presentmentTitle: import_zod56.z.string(), title: import_zod56.z.string() })
+  shippingOption: import_zod56.z.object({ presentmentTitle: import_zod56.z.string(), title: import_zod56.z.string() }),
+  /** A switch to subscription (STS): the one subscription that charges no initial shipping (L122). */
+  sts: import_zod56.z.literal(true).optional()
 });
 
 // src/schema/postPurchaseProduct.ts
@@ -6541,7 +6556,8 @@ var PreparedPostPurchaseSubscription = PreparedPostPurchaseProduct.extend({
   terms: PreparedPostPurchaseProduct.shape.terms.extend({
     subscription: PostPurchaseSubscriptionTerms
   }).refine(
-    ({ discount, shipping, subscription: subscription2 }) => (discount.type !== "none" || discount.amount === 0) && shipping.amount === subscription2.initialShippingPrice && shipping.amount === subscription2.recurringShippingPrice && (shipping.type !== "free" || shipping.amount === 0)
+    ({ discount, shipping, subscription: subscription2 }) => (discount.type !== "none" || discount.amount === 0) && // A switch to subscription charges no initial shipping (L122); any other subscription charges it.
+    subscription2.initialShippingPrice === (subscription2.sts ? 0 : shipping.amount) && shipping.amount === subscription2.recurringShippingPrice && (shipping.type !== "free" || shipping.amount === 0)
   )
 });
 
@@ -6889,6 +6905,7 @@ var prepareNormalizedSubscription = (normalized, report, plan, quantity3, allowC
   const projected = projectPostPurchaseProduct(normalized, report, quantity3);
   const { discount, shipping } = PostPurchaseSubscriptionSettings.parse(effective.subscription);
   const shippingPrice = shipping.type === "free" ? 0 : shipping.amount;
+  const sts = quantity3?.sts === true;
   return PreparedPostPurchaseSubscription.parse({
     ...projected,
     display: { ...projected.display, shouldShowSavingText: discount.shouldShowSavingText },
@@ -6903,11 +6920,12 @@ var prepareNormalizedSubscription = (normalized, report, plan, quantity3, allowC
       shipping: { amount: shippingPrice, title: "Subscription shipping line", type: shipping.type },
       subscription: {
         ...plan.adjustment ? { adjustment: plan.adjustment } : {},
-        initialShippingPrice: shippingPrice,
+        initialShippingPrice: sts ? 0 : shippingPrice,
         intervalLabel: plan.intervalLabel,
         name: plan.name,
         recurringShippingPrice: shippingPrice,
-        shippingOption: { presentmentTitle: "Subscription shipping line", title: "Subscription shipping line" }
+        shippingOption: { presentmentTitle: "Subscription shipping line", title: "Subscription shipping line" },
+        ...sts ? { sts } : {}
       }
     }
   });
@@ -7117,6 +7135,7 @@ var PostPurchaseProductChangeset = import_zod72.z.object({
 });
 
 // src/schema/postPurchaseProductView.ts
+var StsMarker = import_zod73.z.literal(true).optional();
 var PostPurchaseProductView = import_zod73.z.union([
   import_zod73.z.object({
     changeset: PostPurchaseProductChangeset.optional(),
@@ -7132,6 +7151,7 @@ var PostPurchaseProductView = import_zod73.z.union([
     }),
     purchaseOptions: PostPurchaseOptions.optional(),
     sections: CABRootSection,
+    sts: StsMarker,
     variantCatalog: PostPurchaseVariantCatalog.optional()
   }),
   import_zod73.z.object({
@@ -7144,6 +7164,7 @@ var PostPurchaseProductView = import_zod73.z.union([
     purchaseOptions: PostPurchaseOptions.optional(),
     /** A choice-level unavailable product keeps its card (values resolve blank); configuration failures send null. */
     sections: CABRootSection.nullable(),
+    sts: StsMarker,
     variantCatalog: PostPurchaseVariantCatalog.optional()
   })
 ]);
@@ -7175,7 +7196,22 @@ var postPurchaseOfferCopy = (blocks, metadata) => {
 };
 
 // src/server/postPurchaseCardSections.ts
-var postPurchaseCardSections = (widgetId, { effective, metadata }, report) => {
+var stsCardSettings = ({ language: language3, productOptions, ...effective }) => ({
+  ...effective,
+  language: {
+    ...language3,
+    global: {
+      ...language3.global,
+      payNow: language3.global.payNowUpgradeToSubscription || "Upgrade to Subscription"
+    }
+  },
+  productOptions: { ...productOptions, showShipping: false }
+});
+var postPurchaseCardSections = (widgetId, {
+  effective: configured,
+  metadata
+}, report, sts = false) => {
+  const effective = sts ? stsCardSettings(configured) : configured;
   if (!effective.blocks?.length) return null;
   const sections = convertMessagePreview(
     widgetId,
@@ -7234,21 +7270,32 @@ var prepareNormalizedPostPurchaseView = (widgetId, normalized, report, choice, q
   const selected = selectPostPurchaseChoice(normalized, planCatalog, choice, allowCollection, quantity3);
   const purchaseOptions = selected.options;
   const labels = { notAvailable: normalized.effective.language.global.notAvailable };
+  const sts = quantity3?.sts === true;
+  const marker = sts ? { sts: true } : {};
   const preparation = !selected.choice ? { reason: selected.reason, status: "unsupported" } : selected.choice.mode === "subscription" ? prepareNormalizedSubscription(normalized, report, selected.plan, quantity3, allowCollection) : prepareNormalizedProduct(normalized, report, quantity3, allowCollection);
   if (preparation.status === "unsupported") {
-    const sections2 = isChoiceUnavailable(preparation.reason) ? postPurchaseCardSections(widgetId, normalized, report) : null;
-    return PostPurchaseProductView.parse({ labels, planCatalog, preparation, purchaseOptions, sections: sections2 });
+    const sections2 = isChoiceUnavailable(preparation.reason) ? postPurchaseCardSections(widgetId, normalized, report, sts) : null;
+    return PostPurchaseProductView.parse({
+      labels,
+      planCatalog,
+      preparation,
+      purchaseOptions,
+      sections: sections2,
+      ...marker
+    });
   }
-  const sections = postPurchaseCardSections(widgetId, normalized, report);
+  const sections = postPurchaseCardSections(widgetId, normalized, report, sts);
   if (!sections)
     return {
       labels,
       planCatalog,
       preparation: { reason: "One fixed product information block is required", status: "unsupported" },
       purchaseOptions,
-      sections: null
+      sections: null,
+      ...marker
     };
   return PostPurchaseProductView.parse({
+    ...marker,
     planCatalog,
     preparation: {
       ...preparation,
@@ -7449,8 +7496,8 @@ var normalizePostPurchaseCollection = (settings, response, excludedProductIds, r
   const limit = import_zod82.z.number().int().positive();
   limit.parse(normalized.original.productLimit);
   const cap = limit.parse(normalized.effective.productLimit);
-  const prefix = products.filter(({ productIndex }) => productIndex < cap);
-  const unread = dropped.filter(({ productIndex }) => productIndex < cap);
+  const prefix = underPostPurchaseCap(products, cap);
+  const unread = underPostPurchaseCap(dropped, cap);
   if (unread.length && !prefix.length) throw new import_zod82.ZodError(unread.flatMap(({ issues }) => issues));
   if (new Set(prefix.map(({ product }) => product.id)).size !== prefix.length)
     throw new Error("Ambiguous post-purchase collection");