@rebuy/rebuy 3.51.1 → 3.53.0

package/dist/server/__fixtures__/postPurchaseSts.d.ts

@@ -0,0 +1,98 @@
+/** The STS Flow: the subscription fixture with STS on and the refund notice asked for. */
+export declare const stsSettings: {
+    upgrade_to_subscription: {
+        allow: boolean;
+        email_refund_notice: boolean;
+    };
+    discount: {
+        amount: number;
+        type: string;
+    };
+    product_type: string;
+    subscription: {
+        discount: {
+            amount: number;
+            type: string;
+        };
+        shipping: {
+            amount: number;
+            type: string;
+        };
+    };
+    blocks: {
+        type: string;
+    }[];
+    endpoint: string;
+    integrations: {};
+    key: string;
+    language: {};
+    product_limit: number;
+    product_options: {};
+    quantity_inputs: {
+        default_quantity: number;
+        enabled: boolean;
+    };
+    shipping: {
+        amount: string;
+        title: string;
+        type: string;
+    };
+};
+export declare const stsResponse: {
+    data: {
+        selling_plan_groups: {
+            id: string;
+            requires_selling_plan: boolean;
+            selling_plans: {
+                id: number;
+                name: string;
+                options: {
+                    name: string;
+                    position: number;
+                    value: string;
+                }[];
+                price_adjustments: never[];
+            }[];
+        }[];
+        variants: {
+            selling_plan_allocations: {
+                selling_plan_group_id: string;
+                selling_plan_id: number;
+            }[];
+            compare_at_price: string;
+            id: number;
+            inventory_management: string;
+            inventory_policy: string;
+            inventory_quantity: number;
+            price: string;
+            product_id: number;
+            title: string;
+        }[];
+        description: string;
+        id: number;
+        image: {
+            src: string;
+        };
+        title: string;
+    }[];
+    metadata: {};
+};
+/** The buyer bought variant 411 of product 410 one-time, three of them. */
+export declare const oneTimeLine: {
+    productId: number;
+    quantity: number;
+    variantId: number;
+};
+export declare const stsContext: {
+    originalLineItems: {
+        productId: number;
+        quantity: number;
+        variantId: number;
+    }[];
+};
+/**
+ * Wraps `call` so every existing case also runs with the STS argument at position `index` and proves the
+ * output byte-identical (or the same failure). Use it only where the Offer does not enable STS, or with
+ * an argument that leaves STS off.
+ */
+export declare const provingStsInert: <A extends unknown[], R>(call: (...args: A) => R, index: number, sts: unknown) => (...args: A) => R;

package/dist/server/classifyPostPurchaseOffer.d.ts

@@ -1,3 +1,5 @@
 import { type z } from 'zod';
-import { type PostPurchaseOfferEligibility, PostPurchaseOfferEligibilityContext } from '../schema/postPurchaseOfferEligibility';
-export declare const classifyPostPurchaseOffer: (settings: unknown, response: unknown, context: z.input<typeof PostPurchaseOfferEligibilityContext>) => PostPurchaseOfferEligibility;
+import { type PostPurchaseOfferEligibility, PostPurchaseOfferEligibilityContext, PostPurchaseStsOptions } from '../schema/postPurchaseOfferEligibility';
+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;

package/dist/server/index.cjs

@@ -6368,6 +6368,12 @@ var import_zod54 = require("zod");
 // src/schema/postPurchaseProductGallery.ts
 var import_zod52 = require("zod");
 var PostPurchaseProductGallery = import_zod52.z.object({
+  /**
+   * Show the thumbnail row: the product had more than one image before `images` was capped at the
+   * sub-image limit, and that limit allows at least one thumbnail. It stays true when the cap leaves one
+   * image (legacy checks the count before slicing). Older replies omit it; fall back to `images.length > 1`.
+   */
+  hasMultiple: import_zod52.z.boolean().optional(),
   images: import_zod52.z.array(
     import_zod52.z.object({
       description: import_zod52.z.string(),
@@ -6533,9 +6539,12 @@ var subscriptionUnavailable = (normalized, plan, allowCollection, quantity3) =>
   const { data, effective, original } = normalized;
   const unavailable = "An eligible subscription plan with supported shipping and discount is required";
   if (data.length !== 1 || data[0].variants.length !== 1) return unavailable;
-  if (effective.productType === "one-time" || [original, effective].some(
-    (config) => !allowCollection && config.productLimit !== 1 || config.upgradeToSubscription.allow || !quantity3 && config.quantityInputs.enabled && (config.quantityInputs.minValue !== config.quantityInputs.maxValue || config.quantityInputs.defaultQuantity !== config.quantityInputs.minValue)
-  ))
+  if (
+    // Legacy STS ran whatever the product type: its trigger forced the subscription option on.
+    effective.productType === "one-time" && !quantity3?.sts || [original, effective].some(
+      (config) => !allowCollection && config.productLimit !== 1 || config.upgradeToSubscription.allow && !quantity3?.sts || !quantity3 && config.quantityInputs.enabled && (config.quantityInputs.minValue !== config.quantityInputs.maxValue || config.quantityInputs.defaultQuantity !== config.quantityInputs.minValue)
+    )
+  )
     return unavailable;
   const product = data[0];
   const variant2 = product.variants[0];
@@ -6560,15 +6569,19 @@ var postPurchasePrimaryImage = (product) => {
 };
 
 // src/server/postPurchaseProductGallery.ts
-var postPurchaseProductGallery = (product, limit) => ({
-  images: (product.images ?? []).slice(0, limit ?? 0).map((image) => ({
-    description: image.alt ?? product.title,
-    id: image.id,
-    source: sizeImageSource(image.src, "800x800"),
-    thumbnail: sizeImageSource(image.src, "200x200")
-  })),
-  selectedImageId: product.images?.find((image) => image.id === product.variants[0].imageId)?.id
-});
+var postPurchaseProductGallery = (product, limit) => {
+  const cap = Math.max(Math.floor(limit ?? 0), 0);
+  return {
+    hasMultiple: (product.images?.length ?? 0) > 1 && cap >= 1,
+    images: (product.images ?? []).slice(0, cap).map((image) => ({
+      description: image.alt ?? product.title,
+      id: image.id,
+      source: sizeImageSource(image.src, "800x800"),
+      thumbnail: sizeImageSource(image.src, "200x200")
+    })),
+    selectedImageId: product.images?.find((image) => image.id === product.variants[0].imageId)?.id
+  };
+};
 
 // src/transforms/postPurchase/convertDescriptionRte.ts
 var import_zod58 = require("zod");
@@ -7261,7 +7274,7 @@ var PostPurchaseMemberIdentity = import_zod75.z.object({
 }).strict();
 
 // src/schema/postPurchaseAdmission.ts
-var PurchaseAdmissionModeSchema = import_zod76.z.enum(["purchase", "upgrade"]);
+var PurchaseAdmissionModeSchema = import_zod76.z.enum(["purchase", "sts"]);
 var selection = PreparedPostPurchaseProduct.shape.selection;
 var EventCalculationSchema = PostPurchaseProductCosts.pick({ currencyCode: true, totalMinor: true }).strict();
 var PurchaseExpectedSchema = import_zod76.z.object({
@@ -7283,8 +7296,8 @@ var PurchaseExpectedSchema = import_zod76.z.object({
   ({ member, progressRevision }) => !member || progressRevision !== void 0,
   "Captured member requires progress"
 ).refine(
-  ({ mode, selection: { sellingPlanId } }) => mode !== "upgrade" || sellingPlanId !== void 0,
-  "An upgrade selects a subscription"
+  ({ mode, selection: { sellingPlanId } }) => mode !== "sts" || sellingPlanId !== void 0,
+  "An STS selects a subscription"
 ).refine(({ buyerConsentToSubscriptions: consent, changeset, selection: selection4 }) => {
   const [change, shipping] = changeset.changes;
   if (selection4.sellingPlanId === void 0)
@@ -7300,7 +7313,7 @@ var PurchaseReceiptSchema = import_zod76.z.object({
   changesetToken: import_zod76.z.string().min(1),
   mode: PurchaseAdmissionModeSchema.optional(),
   operationId: import_zod76.z.uuid(),
-  /** The server-bound one-time line an upgrade refunds; its quantity is the order's, not the selection's. */
+  /** The server-bound one-time line an STS refunds; its quantity is the order's, not the selection's. */
   originalLine: import_zod76.z.strictObject({ quantity: selection.shape.quantity, variantId: selection.shape.variantId }).optional(),
   requiresSubscriptionConsent: import_zod76.z.boolean(),
   selection
@@ -7308,8 +7321,8 @@ var PurchaseReceiptSchema = import_zod76.z.object({
   ({ requiresSubscriptionConsent, selection: selection4 }) => requiresSubscriptionConsent === (selection4.sellingPlanId !== void 0),
   "Receipt consent must match its selected plan"
 ).refine(
-  ({ mode, originalLine, selection: { sellingPlanId, variantId } }) => mode === "upgrade" ? sellingPlanId !== void 0 && originalLine?.variantId === variantId : originalLine === void 0,
-  "An upgrade Receipt binds the original line of its subscribed variant, and only an upgrade does"
+  ({ mode, originalLine, selection: { sellingPlanId, variantId } }) => mode === "sts" ? sellingPlanId !== void 0 && originalLine?.variantId === variantId : originalLine === void 0,
+  "An STS Receipt binds the original line of its subscribed variant, and only an STS does"
 );
 var PurchaseResponseSchema = import_zod76.z.object({ data: PurchaseReceiptSchema, successful: import_zod76.z.literal(true) });
 
@@ -7433,14 +7446,41 @@ var projectPostPurchaseVariantCatalog = (product, settings) => {
   });
 };
 
-// src/schema/postPurchaseQuantity.ts
+// src/schema/postPurchaseOfferEligibility.ts
 var import_zod82 = require("zod");
+var selection2 = PreparedPostPurchaseProduct.shape.selection;
+var PostPurchaseOfferSkipReason = import_zod82.z.enum(["empty", "no-eligible-subscription"]);
+var PostPurchaseOfferEligibilityContext = import_zod82.z.object({
+  excludedProductIds: PostPurchaseExcludedProductIds,
+  originalLineItems: import_zod82.z.array(selection2.pick({ productId: true, sellingPlanId: true, variantId: true }))
+});
+var PostPurchaseStsOptions = import_zod82.z.object({ sts: import_zod82.z.boolean().optional() }).strict();
+var PostPurchaseStsContext = import_zod82.z.object({
+  originalLineItems: import_zod82.z.array(
+    selection2.pick({ productId: true, quantity: true, sellingPlanId: true, variantId: true })
+  )
+});
+var PostPurchaseOfferEligibility = import_zod82.z.discriminatedUnion("status", [
+  import_zod82.z.object({
+    members: import_zod82.z.array(
+      import_zod82.z.object({ productId: selection2.shape.productId, productIndex: import_zod82.z.number().int().nonnegative() })
+    ),
+    /** Present only with STS on: each member switches one original one-time line to subscription. */
+    mode: import_zod82.z.literal("sts").optional(),
+    status: import_zod82.z.literal("retain")
+  }),
+  import_zod82.z.object({ reason: PostPurchaseOfferSkipReason, status: import_zod82.z.literal("skip") }),
+  import_zod82.z.object({ reason: import_zod82.z.literal("eligible-sts").optional(), status: import_zod82.z.literal("unavailable") })
+]);
+
+// src/schema/postPurchaseQuantity.ts
+var import_zod83 = require("zod");
 var quantity2 = PreparedPostPurchaseProduct.shape.selection.shape.quantity;
 var PostPurchaseQuantityChoice = PostPurchaseCollectionChoice.extend({ quantity: quantity2.optional() });
 var PostPurchaseQuantityPolicy = PostPurchaseSettings.shape.quantityInputs.omit({ defaultQuantity: true }).extend({
   initialQuantity: quantity2,
   maxValue: quantity2,
-  minValue: import_zod82.z.literal(0).transform(() => 1).or(quantity2)
+  minValue: import_zod83.z.literal(0).transform(() => 1).or(quantity2)
 }).refine(({ maxValue, minValue }) => minValue <= maxValue, "Quantity bounds are reversed");
 
 // src/server/readPostPurchaseQuantity.ts
@@ -7470,40 +7510,88 @@ var readPostPurchaseQuantity = ({
   return { policy, quantity: quantity3 };
 };
 
+// src/server/postPurchaseSts.ts
+var stsAllowed = ({ effective, original }) => [original, effective].some((config) => config.upgradeToSubscription.allow);
+var postPurchaseStsLine = (normalized, product, lines, variantId) => {
+  if (!product.sellingPlanGroups?.length || product.productGroupVariants.length) return void 0;
+  for (const variant2 of product.variants) {
+    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] };
+  }
+};
+var preparePostPurchaseStsView = (widgetId, normalized, product, context, requested, report) => {
+  const { originalLineItems } = PostPurchaseStsContext.parse(context);
+  const found = postPurchaseStsLine(normalized, product, originalLineItems, requested.variantId);
+  if (!found) return null;
+  const whole = found.line.quantity;
+  if (requested.quantity !== void 0 && requested.quantity !== whole)
+    throw new PostPurchaseQuantityUnavailable("An STS covers the whole original quantity");
+  const bounds = { initialQuantity: whole, maxValue: whole, minValue: whole };
+  const policy = PostPurchaseQuantityPolicy.parse({ enabled: false, ...bounds });
+  const quantity3 = { policy, quantity: whole, sts: true };
+  const input = { ...normalized, data: found.data };
+  return {
+    quantity: quantity3,
+    sts: {
+      emailRefundNotice: normalized.effective.upgradeToSubscription.emailRefundNotice,
+      originalLine: { quantity: whole, variantId: found.line.variantId }
+    },
+    view: prepareNormalizedPostPurchaseView(widgetId, input, report, requested.choice, quantity3, true)
+  };
+};
+var prepareStsCollectionMember = (widgetId, normalized, { product, productIndex }, context, choice, report) => {
+  const stsResult = preparePostPurchaseStsView(widgetId, normalized, product, context, { choice }, report);
+  return stsResult && { productId: product.id, productIndex, reportingProduct: void 0, view: stsResult.view };
+};
+
+// src/server/preparePostPurchaseStsMember.ts
+var preparePostPurchaseStsMember = (widgetId, settings, response, selected, sts, requestedQuantity, report) => {
+  const { members, normalized } = normalizePostPurchaseCollection(settings, response);
+  if (!stsAllowed(normalized)) return void 0;
+  const member = members.find(({ product }) => product.id === selected.productId);
+  const quantity3 = requestedQuantity && ("quantity" in requestedQuantity ? requestedQuantity.quantity : requestedQuantity.expectedQuantity);
+  const prepared = member && preparePostPurchaseStsView(widgetId, normalized, member.product, sts, { ...selected, quantity: quantity3 }, report);
+  if (!member || !prepared) return null;
+  const { view, ...facts } = prepared;
+  return { ...facts, member: { productId: member.product.id, productIndex: member.productIndex, view }, normalized };
+};
+
 // src/schema/postPurchaseVariantDefault.ts
-var import_zod83 = require("zod");
+var import_zod84 = require("zod");
 var values = PostPurchaseVariantValues.partial().extend({
   option1: PostPurchaseVariantValues.shape.option1.nullish()
 });
 var variant = values.extend({
   id: PostPurchaseVariantId,
-  inventoryManagement: import_zod83.z.string().nullable(),
-  inventoryPolicy: import_zod83.z.string(),
-  inventoryQuantity: import_zod83.z.number()
+  inventoryManagement: import_zod84.z.string().nullable(),
+  inventoryPolicy: import_zod84.z.string(),
+  inventoryQuantity: import_zod84.z.number()
 });
-var options = import_zod83.z.array(PostPurchaseVariantOption.pick({ name: true, values: true }));
-var PostPurchaseVariantDefaultProduct = import_zod83.z.object({
+var options = import_zod84.z.array(PostPurchaseVariantOption.pick({ name: true, values: true }));
+var PostPurchaseVariantDefaultProduct = import_zod84.z.object({
   id: PostPurchaseProductId,
   options,
   selectedVariant: variant.optional(),
-  variants: import_zod83.z.array(variant)
+  variants: import_zod84.z.array(variant)
 });
 var PostPurchaseVariantDefaultSettings = PostPurchaseSettings.shape.productOptions.pick({
   hideOutOfStockVariants: true,
   matchVariant: true
 });
-var PostPurchaseOrderAttributes = import_zod83.z.record(import_zod83.z.string(), import_zod83.z.array(import_zod83.z.string())).default({});
-var PostPurchaseOriginalVariants = import_zod83.z.array(
-  import_zod83.z.object({ productId: PostPurchaseProductId, variantId: PostPurchaseVariantId })
+var PostPurchaseOrderAttributes = import_zod84.z.record(import_zod84.z.string(), import_zod84.z.array(import_zod84.z.string())).default({});
+var PostPurchaseOriginalVariants = import_zod84.z.array(
+  import_zod84.z.object({ productId: PostPurchaseProductId, variantId: PostPurchaseVariantId })
 );
-var PostPurchaseAttributeProducts = import_zod83.z.array(
-  import_zod83.z.object({ id: PostPurchaseProductId, options, variants: import_zod83.z.array(values.extend({ id: PostPurchaseVariantId })) })
+var PostPurchaseAttributeProducts = import_zod84.z.array(
+  import_zod84.z.object({ id: PostPurchaseProductId, options, variants: import_zod84.z.array(values.extend({ id: PostPurchaseVariantId })) })
 );
 
 // src/schema/postPurchaseVariantDefaultContext.ts
-var import_zod84 = require("zod");
-var PostPurchaseVariantDefaultContext = import_zod84.z.object({
-  enrichedLineItems: import_zod84.z.unknown().optional(),
+var import_zod85 = require("zod");
+var PostPurchaseVariantDefaultContext = import_zod85.z.object({
+  enrichedLineItems: import_zod85.z.unknown().optional(),
   originalVariants: PostPurchaseOriginalVariants
 });
 
@@ -7578,8 +7666,10 @@ var resolvePostPurchaseMemberDefault = (product, original, context) => {
 };
 
 // src/server/preparePostPurchaseMemberView.ts
-var prepareMember = (widgetId, settings, response, requested, report, excludedProductIds, requestedQuantity, defaults) => {
+var prepareMember = (widgetId, settings, response, requested, report, excludedProductIds, requestedQuantity, defaults, sts) => {
   const selected = PostPurchaseCollectionChoice.parse(requested);
+  const stsResult = sts && preparePostPurchaseStsMember(widgetId, settings, response, selected, sts, requestedQuantity, report);
+  if (stsResult !== void 0) return stsResult;
   const { members, normalized } = normalizePostPurchaseCollection(settings, response, excludedProductIds);
   const found = members.find(({ product: product2 }) => product2.id === selected.productId);
   if (!found) return null;
@@ -7606,7 +7696,7 @@ var preparePostPurchaseMemberAdmissionView = (widgetId, settings, response, requ
 };
 
 // src/server/preparePostPurchaseQuantityView.ts
-var preparePostPurchaseQuantityView = (widgetId, settings, response, requested, report, excludedProductIds, defaults) => {
+var preparePostPurchaseQuantityView = (widgetId, settings, response, requested, report, excludedProductIds, defaults, sts) => {
   const { quantity: quantity3, ...selection4 } = PostPurchaseQuantityChoice.parse(requested);
   const prepared = prepareMember(
     widgetId,
@@ -7616,15 +7706,21 @@ var preparePostPurchaseQuantityView = (widgetId, settings, response, requested,
     report,
     excludedProductIds,
     { quantity: quantity3 },
-    defaults
+    defaults,
+    sts
   );
-  return prepared ? { ...prepared.member, quantityPolicy: prepared.quantity.policy } : null;
+  if (!prepared) return null;
+  return {
+    ...prepared.member,
+    quantityPolicy: prepared.quantity.policy,
+    ..."sts" in prepared && { sts: prepared.sts }
+  };
 };
 
 // src/server/preparePostPurchaseQuantityAdmissionView.ts
-var selection2 = PostPurchaseQuantityChoice.required({ quantity: true });
-var preparePostPurchaseQuantityAdmissionView = (widgetId, settings, response, expected, report, excludedProductIds, defaults) => {
-  const { quantity: expectedQuantity, ...requested } = selection2.parse(expected);
+var selection3 = PostPurchaseQuantityChoice.required({ quantity: true });
+var preparePostPurchaseQuantityAdmissionView = (widgetId, settings, response, expected, report, excludedProductIds, defaults, sts) => {
+  const { quantity: expectedQuantity, ...requested } = selection3.parse(expected);
   const prepared = prepareMember(
     widgetId,
     settings,
@@ -7633,11 +7729,17 @@ var preparePostPurchaseQuantityAdmissionView = (widgetId, settings, response, ex
     report,
     excludedProductIds,
     { expectedQuantity },
-    defaults
+    defaults,
+    sts
   );
   if (!prepared) return null;
   const { removePartialOrder } = PostPurchaseSettings.shape.advance.parse(prepared.normalized.effective.advance);
-  return { ...prepared.member, quantityPolicy: prepared.quantity.policy, removePartialOrder };
+  return {
+    ...prepared.member,
+    quantityPolicy: prepared.quantity.policy,
+    removePartialOrder,
+    ..."sts" in prepared && { sts: prepared.sts }
+  };
 };
 
 // src/schema/postPurchaseGroup.ts
@@ -7800,11 +7902,16 @@ var preparePostPurchaseCollectionGroup = (widgetId, settings, response, member,
 
 // src/server/preparePostPurchaseCollectionView.ts
 var CollectionChoice = PostPurchaseCollectionChoice.omit({ variantId: true });
-var preparePostPurchaseCollectionView = (widgetId, settings, response, report, requested, excludedProductIds, defaults = { originalVariants: [] }) => {
+var preparePostPurchaseCollectionView = (widgetId, settings, response, report, requested, excludedProductIds, defaults, sts) => {
   const { members, normalized } = normalizePostPurchaseCollection(settings, response);
   const excluded = PostPurchaseExcludedProductIds.parse(excludedProductIds);
   const selected = CollectionChoice.optional().parse(requested);
+  const stsMode = sts && stsAllowed(normalized) ? sts : void 0;
   const projected = members.map((member) => {
+    if (stsMode) {
+      const choice = member.product.id === selected?.productId ? selected.choice : void 0;
+      return prepareStsCollectionMember(widgetId, normalized, member, stsMode, choice, report);
+    }
     if (member.product.productGroupVariants.length) {
       if (selected?.productId === member.product.id && selected.choice)
         throw new Error("Grouped choices require selected merchandise");
@@ -7815,7 +7922,7 @@ var preparePostPurchaseCollectionView = (widgetId, settings, response, report, r
         member,
         normalized,
         excluded,
-        defaults,
+        defaults ?? { originalVariants: [] },
         report
       );
       return group;
@@ -7846,25 +7953,6 @@ var preparePostPurchaseCollectionView = (widgetId, settings, response, report, r
   };
 };
 
-// src/schema/postPurchaseOfferEligibility.ts
-var import_zod85 = require("zod");
-var selection3 = PreparedPostPurchaseProduct.shape.selection;
-var PostPurchaseOfferSkipReason = import_zod85.z.enum(["empty", "no-eligible-subscription"]);
-var PostPurchaseOfferEligibilityContext = import_zod85.z.object({
-  excludedProductIds: PostPurchaseExcludedProductIds,
-  originalLineItems: import_zod85.z.array(selection3.pick({ productId: true, sellingPlanId: true, variantId: true }))
-});
-var PostPurchaseOfferEligibility = import_zod85.z.discriminatedUnion("status", [
-  import_zod85.z.object({
-    members: import_zod85.z.array(
-      import_zod85.z.object({ productId: selection3.shape.productId, productIndex: import_zod85.z.number().int().nonnegative() })
-    ),
-    status: import_zod85.z.literal("retain")
-  }),
-  import_zod85.z.object({ reason: PostPurchaseOfferSkipReason, status: import_zod85.z.literal("skip") }),
-  import_zod85.z.object({ reason: import_zod85.z.literal("eligible-upgrade").optional(), status: import_zod85.z.literal("unavailable") })
-]);
-
 // src/server/postPurchaseMemberEligibility.ts
 var PostPurchaseInventoryUnavailable = class extends Error {
 };
@@ -7893,22 +7981,28 @@ var postPurchaseMemberEligibility = (normalized, product, excluded) => {
 };
 
 // src/server/classifyPostPurchaseOffer.ts
-var classifyPostPurchaseOffer = (settings, response, context) => {
+var identities = (members) => members.map(({ product, productIndex }) => ({ productId: product.id, productIndex }));
+var classifyPostPurchaseOffer = (settings, response, context, options2) => {
   try {
     const trusted = PostPurchaseOfferEligibilityContext.parse(context);
+    const { sts: stsMode = false } = PostPurchaseStsOptions.parse(options2 ?? {});
     const { members, normalized } = normalizePostPurchaseCollection(settings, response);
     const configurations = [normalized.original, normalized.effective];
-    const upgrades = configurations.some((config) => config.upgradeToSubscription.allow);
+    const stsEnabled = configurations.some((config) => config.upgradeToSubscription.allow);
+    const sts = stsEnabled && stsMode;
     const oneTime = new Set(
       trusted.originalLineItems.filter((line) => line.sellingPlanId === void 0).map((line) => line.variantId)
     );
-    if (upgrades && members.some(
+    if (stsEnabled && !stsMode && members.some(
       ({ product }) => product.sellingPlanGroups?.length && product.variants.some((variant2) => oneTime.has(variant2.id))
     ))
-      return { reason: "eligible-upgrade", status: "unavailable" };
-    if (normalized.effective.productType !== "one-time") {
+      return { reason: "eligible-sts", status: "unavailable" };
+    if (normalized.effective.productType !== "one-time" || sts) {
       configurations.forEach((config) => PostPurchaseSubscriptionSettings.parse(config.subscription));
     }
+    const lines = trusted.originalLineItems;
+    const stsMembers = sts ? members.filter(({ product }) => postPurchaseStsLine(normalized, product, lines)) : [];
+    if (stsMembers.length) return { members: identities(stsMembers), mode: "sts", status: "retain" };
     const classified = members.map((member) => {
       try {
         return {
@@ -7922,19 +8016,13 @@ var classifyPostPurchaseOffer = (settings, response, context) => {
       }
     });
     if (!members.length) return { reason: "empty", status: "skip" };
-    if (upgrades) return { reason: "no-eligible-subscription", 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)
     );
     if (!candidates.length) return { reason: "empty", status: "skip" };
     const retained = candidates.filter(({ eligible }) => eligible);
-    return retained.length ? {
-      members: retained.map(({ product, productIndex }) => ({
-        productId: product.id,
-        productIndex
-      })),
-      status: "retain"
-    } : { reason: "no-eligible-subscription", status: "skip" };
+    return retained.length ? { members: identities(retained), status: "retain" } : { reason: "no-eligible-subscription", status: "skip" };
   } catch {
     return { status: "unavailable" };
   }