@saasicat/nest 1.0.0-rc.2 → 1.0.0-rc.21

package/dist/chunk-55QEDAMX.js

@@ -0,0 +1,946 @@
+import {
+  PromoCodesService,
+  computeDiscountGross
+} from "./chunk-3RLWML2S.js";
+import {
+  SubscriptionContractService,
+  appendImplicitDiscountLineItem
+} from "./chunk-NDLC5GYK.js";
+import {
+  resolveBundlePriceNet
+} from "./chunk-KPEMTBOP.js";
+import {
+  grossFromNet,
+  netFromGross,
+  round2
+} from "./chunk-6PJE7EWO.js";
+import {
+  BUNDLE_REPOSITORY_TOKEN,
+  CATALOG_ENTRY_REPOSITORY_TOKEN,
+  PLAN_REPOSITORY_TOKEN,
+  PROMOTION_REPOSITORY_TOKEN
+} from "./chunk-3QVGA6JX.js";
+import {
+  SubscriberService,
+  settleNewSubscriberDetails
+} from "./chunk-LF6J4YYN.js";
+import {
+  PLAN_CATALOG_SETTINGS_TOKEN
+} from "./chunk-FEQZCWUL.js";
+import {
+  codedError
+} from "./chunk-J7NJRK3K.js";
+import {
+  __name
+} from "./chunk-SHUYVCID.js";
+
+// src/checkout-offer/checkout-offer-pricing.ts
+import { Inject, Injectable, Optional, UnprocessableEntityException } from "@nestjs/common";
+import { CONTRACT_ERROR_CODES, promotionOnPrice } from "@saasicat/core";
+
+// src/checkout-offer/bundle-version-bookable.ts
+import { startOfUtcDay } from "@saasicat/core";
+function bundleVersionNotBookableReason(version, nowMs) {
+  if (version.publishedAt === null) return "not_published";
+  if (version.supersededAt !== null) return "superseded";
+  if (dateIsAfter(version.validFrom, nowMs)) return "not_yet_valid";
+  if (isValidUntilExpired(version.validUntil, nowMs)) return "expired";
+  return null;
+}
+__name(bundleVersionNotBookableReason, "bundleVersionNotBookableReason");
+function dateIsAfter(value, nowMs) {
+  if (!value) return false;
+  const time = new Date(value).getTime();
+  return Number.isNaN(time) || time > nowMs;
+}
+__name(dateIsAfter, "dateIsAfter");
+function isValidUntilExpired(value, nowMs) {
+  if (!value) return false;
+  const validUntil = new Date(value).getTime();
+  if (Number.isNaN(validUntil)) return true;
+  return validUntil < startOfUtcDay(new Date(nowMs)).getTime();
+}
+__name(isValidUntilExpired, "isValidUntilExpired");
+
+// src/checkout-offer/checkout-offer-pricing.ts
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+function _ts_param(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param, "_ts_param");
+var DEFAULT_LOCALE = "de";
+var CheckoutOfferPricing = class {
+  static {
+    __name(this, "CheckoutOfferPricing");
+  }
+  settings;
+  plans;
+  bundles;
+  promotions;
+  promoCodes;
+  constructor(settings, plans, bundles = null, promotions = null, promoCodes = null) {
+    this.settings = settings;
+    this.plans = plans;
+    this.bundles = bundles;
+    this.promotions = promotions;
+    this.promoCodes = promoCodes;
+  }
+  /** Prices a selection against the plan version on sale now. */
+  async price(input, asOf = /* @__PURE__ */ new Date()) {
+    const planVersion = await this.planVersionOnSale(input.planKey, input.billingCycle, asOf);
+    const bundleVersions = await this.bundleVersionsFor(input, asOf, true);
+    return this.compute(input, planVersion, bundleVersions, asOf);
+  }
+  /**
+   * Throws unless the offer's stored amounts are what this pricing makes of
+   * its own selection: the plan and bundle versions it froze, and the
+   * promotions as they stood when it was last priced.
+   */
+  async assertPricedByCatalogue(offer) {
+    const notCurrent = /* @__PURE__ */ __name(() => new UnprocessableEntityException({
+      code: CONTRACT_ERROR_CODES.CHECKOUT_OFFER_PRICE_NOT_CURRENT,
+      message: `The prices of checkout offer '${offer.id}' no longer match the catalogue; create a new offer.`,
+      params: {
+        offerId: offer.id
+      }
+    }), "notCurrent");
+    if (!offer.planVersionId) throw notCurrent();
+    const planVersion = await this.plans.findVersionById?.(offer.planVersionId);
+    if (!planVersion || planVersion.planId !== offer.planKey) throw notCurrent();
+    const input = {
+      planKey: offer.planKey,
+      billingCycle: offer.billingCycle,
+      bundleVersionIds: offer.bundleVersionIds ?? [],
+      promoCode: offer.promoCode,
+      locale: offer.locale,
+      checkoutOfferId: offer.id,
+      concluding: true
+    };
+    const pricedAt = new Date(offer.updatedAt);
+    let repriced;
+    try {
+      this.assertPlanPriced(planVersion, input.billingCycle);
+      const bundleVersions = await this.bundleVersionsFor(input, pricedAt, false);
+      repriced = await this.compute(input, planVersion, bundleVersions, pricedAt);
+    } catch (error) {
+      if (refusesThePromoCode(error)) throw error;
+      if (error instanceof UnprocessableEntityException) throw notCurrent();
+      throw error;
+    }
+    if (moneyOf(repriced) !== moneyOf(offer)) throw notCurrent();
+  }
+  async compute(input, planVersion, bundleVersions, asOf) {
+    const vatRate = this.settings.vatRate;
+    const promotions = this.promotions ? await this.promotions.list() : [];
+    const plan = await this.plans.findByKey(input.planKey);
+    const planLine = this.pricePlan(input, planVersion, plan?.label, promotions, asOf);
+    const bundleLines = bundleVersions.map((version) => this.priceBundle(input, version, promotions, asOf));
+    const promotionSnapshots = [
+      planLine,
+      ...bundleLines
+    ].map((priced) => priced.promotion).filter((promotion) => promotion !== null);
+    const planNet = planLine.line.priceNet;
+    const bundlesNet = round2(bundleLines.reduce((sum, priced) => sum + priced.line.priceNet, 0));
+    const regularNet = round2(planNet + bundlesNet);
+    const promotionDiscount = round2(promotionSnapshots.reduce((sum, promotion) => sum + promotion.resolvedAmountNet, 0));
+    const planNetAfterPromotion = round2(planNet - (planLine.promotion?.resolvedAmountNet ?? 0));
+    const promoCodeSnapshot = await this.pricePromoCode(input, planNetAfterPromotion, vatRate);
+    const effectiveNet = Math.max(0, round2(regularNet - promotionDiscount - (promoCodeSnapshot?.resolvedAmountNet ?? 0)));
+    const priceBreakdown = {
+      currency: this.settings.currency,
+      billingCycle: input.billingCycle,
+      planNet,
+      bundlesNet,
+      regularNet,
+      effectiveNet,
+      vatRate,
+      effectiveGross: grossFromNet(effectiveNet, vatRate)
+    };
+    const lineItems = appendImplicitDiscountLineItem({
+      billingCycle: input.billingCycle,
+      priceBreakdown,
+      lineItems: [
+        planLine.line,
+        ...bundleLines.map((priced) => priced.line)
+      ],
+      promotionSnapshots,
+      promoCodeSnapshot
+    });
+    return {
+      planVersionId: planVersion.id,
+      bundles: bundleVersions.map((version) => version.bundleKey),
+      bundleVersionIds: bundleVersions.map((version) => version.id),
+      promotionId: planLine.promotion?.id ?? null,
+      promoCode: promoCodeSnapshot?.code ?? null,
+      priceBreakdown,
+      lineItems,
+      promotionSnapshots,
+      promoCodeSnapshot
+    };
+  }
+  /** The plan version on sale for new bookings, as the public catalogue resolves it. */
+  async planVersionOnSale(planKey, billingCycle, asOf) {
+    const version = await this.plans.findActivePlanVersion?.(planKey, asOf) ?? (this.plans.findActivePlanVersion ? null : await this.plans.findLatestLivePlanVersion?.(planKey));
+    if (!version) throw planNotOffered(planKey, billingCycle);
+    this.assertPlanPriced(version, billingCycle);
+    return version;
+  }
+  /** A plan without a list price is not sold at one (`SC-PRIC-011`). */
+  assertPlanPriced(version, billingCycle) {
+    if (version.marketed === false || priceOf(version, billingCycle) === null) {
+      throw planNotOffered(version.planId, billingCycle);
+    }
+  }
+  async bundleVersionsFor(input, asOf, checkBookable) {
+    const ids = input.bundleVersionIds;
+    if (ids.length === 0) return [];
+    const out = [];
+    for (const [index, bundleVersionId] of ids.entries()) {
+      if (ids.indexOf(bundleVersionId) !== index) {
+        throw bundleNotOffered(bundleVersionId, "duplicate");
+      }
+      const version = this.bundles ? await this.bundles.findVersionById(bundleVersionId) : null;
+      if (!version) throw bundleNotOffered(bundleVersionId, "missing");
+      if (checkBookable) {
+        const notBookable = bundleVersionNotBookableReason(version, asOf.getTime());
+        if (notBookable) throw bundleNotOffered(bundleVersionId, notBookable);
+        if (!version.marketed) throw bundleNotOffered(bundleVersionId, "not_marketed");
+      }
+      const planKeys = version.compatibility?.planIds ?? [];
+      if (planKeys.length > 0 && !planKeys.includes(input.planKey)) {
+        throw bundleNotOffered(bundleVersionId, "incompatible_with_plan");
+      }
+      if (resolveBundlePriceNet(version, input.planKey, wireCycle(input.billingCycle)) === null) {
+        throw bundleNotOffered(bundleVersionId, "not_priced");
+      }
+      out.push(version);
+    }
+    return out;
+  }
+  pricePlan(input, version, label, promotions, asOf) {
+    const priceNet = priceOf(version, input.billingCycle);
+    return {
+      line: this.line({
+        kind: "plan",
+        sourceKey: input.planKey,
+        sourceVersionId: version.id,
+        title: label ?? input.planKey,
+        priceNet,
+        billingCycle: input.billingCycle,
+        features: version.features ?? [],
+        quotas: version.quotas ?? {}
+      }),
+      promotion: promotionFor(promotions, input.planKey, "PLAN", input, priceNet, asOf)
+    };
+  }
+  priceBundle(input, version, promotions, asOf) {
+    const priceNet = resolveBundlePriceNet(version, input.planKey, wireCycle(input.billingCycle));
+    return {
+      line: this.line({
+        kind: "bundle",
+        sourceKey: version.bundleKey,
+        sourceVersionId: version.id,
+        title: version.label,
+        priceNet,
+        billingCycle: input.billingCycle,
+        features: version.features ?? [],
+        quotas: version.quotas ?? {}
+      }),
+      promotion: promotionFor(promotions, version.bundleKey, "BUNDLE", input, priceNet, asOf)
+    };
+  }
+  line(fields) {
+    return {
+      kind: fields.kind,
+      sourceKey: fields.sourceKey,
+      sourceVersionId: fields.sourceVersionId,
+      titleSnapshot: fields.title,
+      descriptionSnapshot: null,
+      quantity: 1,
+      unit: null,
+      priceNet: fields.priceNet,
+      priceGross: grossFromNet(fields.priceNet, this.settings.vatRate),
+      billingCycle: fields.billingCycle,
+      featuresSnapshot: [
+        ...fields.features
+      ],
+      quotaEffectsSnapshot: {
+        ...fields.quotas
+      },
+      metadata: null
+    };
+  }
+  /**
+   * The promo code's discount on the plan, after its promotion.
+   *
+   * Eligibility is the promo module's to decide, and it decides on its own
+   * terms: status, validity, the plan and rhythm the code is limited to. Only
+   * the amount is computed here, on the price this offer actually carries.
+   */
+  async pricePromoCode(input, planNet, vatRate) {
+    if (!input.promoCode) return null;
+    if (!this.promoCodes) throw promoCodeNotAccepted("PROMO_CODES_NOT_AVAILABLE");
+    const preview = await this.promoCodes.preview({
+      code: input.promoCode,
+      planId: input.planKey,
+      billingCycle: wireCycle(input.billingCycle)
+    }, {
+      checkoutOfferId: input.checkoutOfferId,
+      concluding: input.concluding
+    });
+    if (!preview.valid) throw promoCodeNotAccepted(preview.reason);
+    const planGross = grossFromNet(planNet, vatRate);
+    const discountGross = Math.min(computeDiscountGross({
+      gross: planGross
+    }, preview.discount), planGross);
+    const resolvedAmountNet = Math.min(planNet, netFromGross(discountGross, vatRate));
+    return {
+      code: preview.code,
+      label: preview.label,
+      valueType: preview.discount.valueType,
+      value: Number(preview.discount.value),
+      resolvedAmountNet,
+      durationType: preview.discount.durationType,
+      durationValue: preview.discount.durationValue
+    };
+  }
+};
+CheckoutOfferPricing = _ts_decorate([
+  Injectable(),
+  _ts_param(0, Inject(PLAN_CATALOG_SETTINGS_TOKEN)),
+  _ts_param(1, Inject(PLAN_REPOSITORY_TOKEN)),
+  _ts_param(2, Optional()),
+  _ts_param(2, Inject(BUNDLE_REPOSITORY_TOKEN)),
+  _ts_param(3, Optional()),
+  _ts_param(3, Inject(PROMOTION_REPOSITORY_TOKEN)),
+  _ts_param(4, Optional()),
+  _ts_param(4, Inject(PromoCodesService)),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof PlanCatalogSettings === "undefined" ? Object : PlanCatalogSettings,
+    typeof PlanRepository === "undefined" ? Object : PlanRepository,
+    Object,
+    Object,
+    Object
+  ])
+], CheckoutOfferPricing);
+function promotionFor(promotions, targetKey, targetType, input, priceNet, asOf) {
+  const shown = promotionOnPrice(promotions, targetKey, input.locale, input.billingCycle, priceNet, asOf, targetType);
+  if (!shown) return null;
+  const { promotion } = shown;
+  const resolvedAmountNet = round2(Math.max(0, priceNet - shown.result.discounted));
+  if (resolvedAmountNet <= 0) return null;
+  const texts = promotion.i18n?.[input.locale] ?? promotion.i18n?.[DEFAULT_LOCALE] ?? {};
+  return {
+    id: promotion.id,
+    type: promotion.type,
+    value: promotion.value,
+    label: texts.badge || promotion.internalLabel,
+    resolvedAmountNet,
+    appliesTo: [
+      targetKey
+    ],
+    billingCycle: promotion.billingCycle
+  };
+}
+__name(promotionFor, "promotionFor");
+function priceOf(version, billingCycle) {
+  const raw = billingCycle === "yearly" ? version.yearlyNet : version.monthlyNet;
+  if (raw === null || raw === void 0) return null;
+  const parsed = Number.parseFloat(raw);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+__name(priceOf, "priceOf");
+function wireCycle(billingCycle) {
+  return billingCycle === "yearly" ? "YEARLY" : "MONTHLY";
+}
+__name(wireCycle, "wireCycle");
+function moneyOf(offer) {
+  const b = offer.priceBreakdown;
+  return JSON.stringify({
+    planVersionId: offer.planVersionId,
+    bundleVersionIds: offer.bundleVersionIds ?? [],
+    promotionId: offer.promotionId,
+    promoCode: offer.promoCode,
+    breakdown: [
+      b.currency,
+      b.billingCycle,
+      b.planNet,
+      b.bundlesNet,
+      b.regularNet,
+      b.effectiveNet,
+      b.vatRate,
+      b.effectiveGross
+    ],
+    // A line's gross is not compared: it is its share of the tax on the
+    // total, derived from the nets and the breakdown compared here, and the
+    // contract derives it again when it is written. So an offer whose stored
+    // lines carry a gross rounded another way still concludes, rather than
+    // being refused over a cent that moved between two of its lines.
+    lines: (offer.lineItems ?? []).map((item) => [
+      item.kind,
+      item.sourceKey,
+      item.sourceVersionId ?? null,
+      item.quantity,
+      item.priceNet,
+      item.billingCycle
+    ]),
+    promotions: (offer.promotionSnapshots ?? []).map((p) => [
+      p.id,
+      p.resolvedAmountNet
+    ]),
+    promoCodeDiscount: offer.promoCodeSnapshot ? [
+      offer.promoCodeSnapshot.code,
+      offer.promoCodeSnapshot.resolvedAmountNet
+    ] : null
+  });
+}
+__name(moneyOf, "moneyOf");
+function planNotOffered(planKey, billingCycle) {
+  return new UnprocessableEntityException({
+    code: CONTRACT_ERROR_CODES.CHECKOUT_OFFER_PLAN_NOT_OFFERED,
+    message: `Plan '${planKey}' is not offered with a ${billingCycle} price at the moment.`,
+    params: {
+      planKey,
+      billingCycle
+    }
+  });
+}
+__name(planNotOffered, "planNotOffered");
+function bundleNotOffered(bundleVersionId, reason) {
+  return new UnprocessableEntityException({
+    code: CONTRACT_ERROR_CODES.CHECKOUT_OFFER_BUNDLE_NOT_OFFERED,
+    message: `Bundle version '${bundleVersionId}' cannot be added to this offer (${reason}).`,
+    params: {
+      bundleVersionId,
+      reason
+    }
+  });
+}
+__name(bundleNotOffered, "bundleNotOffered");
+function refusesThePromoCode(error) {
+  if (!(error instanceof UnprocessableEntityException)) return false;
+  const body = error.getResponse();
+  return typeof body === "object" && body !== null && body.code === CONTRACT_ERROR_CODES.CHECKOUT_OFFER_PROMO_CODE_NOT_ACCEPTED;
+}
+__name(refusesThePromoCode, "refusesThePromoCode");
+function promoCodeNotAccepted(reason) {
+  return new UnprocessableEntityException({
+    code: CONTRACT_ERROR_CODES.CHECKOUT_OFFER_PROMO_CODE_NOT_ACCEPTED,
+    message: `The promo code cannot be applied to this offer (${reason}).`,
+    params: {
+      reason
+    }
+  });
+}
+__name(promoCodeNotAccepted, "promoCodeNotAccepted");
+
+// src/checkout-offer/checkout-offer.tokens.ts
+var CHECKOUT_OFFER_REPOSITORY_TOKEN = /* @__PURE__ */ Symbol.for("saasicat/nest/CheckoutOfferRepository");
+var CHECKOUT_OFFER_TRANSACTION_RUNNER_TOKEN = /* @__PURE__ */ Symbol.for("saasicat/nest/CheckoutOfferTransactionRunner");
+
+// src/checkout-offer/checkout-offer.service.ts
+import { isDeepStrictEqual } from "util";
+import { ConflictException, Inject as Inject2, Injectable as Injectable2, NotFoundException, Optional as Optional2, UnprocessableEntityException as UnprocessableEntityException2 } from "@nestjs/common";
+import { CONTRACT_ERROR_CODES as CONTRACT_ERROR_CODES2, SUBSCRIBER_ERROR_CODES, buildFeatureRequiresIndex, collectUnsatisfiedRequires } from "@saasicat/core";
+function _ts_decorate2(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate2, "_ts_decorate");
+function _ts_metadata2(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata2, "_ts_metadata");
+function _ts_param2(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param2, "_ts_param");
+var DEFAULT_OFFER_LOCALE = "de";
+var HOLD_ATTEMPTS = 3;
+var CheckoutOfferService = class {
+  static {
+    __name(this, "CheckoutOfferService");
+  }
+  repo;
+  pricing;
+  bundles;
+  plans;
+  catalogEntries;
+  contracts;
+  transactions;
+  subscribers;
+  promoCodes;
+  constructor(repo, pricing, bundles = null, plans = null, catalogEntries = null, contracts = null, transactions = null, subscribers = null, promoCodes = null) {
+    this.repo = repo;
+    this.pricing = pricing;
+    this.bundles = bundles;
+    this.plans = plans;
+    this.catalogEntries = catalogEntries;
+    this.contracts = contracts;
+    this.transactions = transactions;
+    this.subscribers = subscribers;
+    this.promoCodes = promoCodes;
+  }
+  list(filter) {
+    return this.repo.list(filter);
+  }
+  async getById(id) {
+    const row = await this.repo.findById(id);
+    if (!row) {
+      throw new NotFoundException({
+        code: CONTRACT_ERROR_CODES2.CHECKOUT_OFFER_NOT_FOUND,
+        message: `CheckoutOffer '${id}' not found`,
+        params: {
+          offerId: id
+        }
+      });
+    }
+    return row;
+  }
+  /** Prices what the caller chose and stores it as an open offer. */
+  async create(selection) {
+    const locale = selection.locale ?? DEFAULT_OFFER_LOCALE;
+    const priced = await this.pricing.price({
+      planKey: selection.planKey,
+      billingCycle: selection.billingCycle,
+      bundleVersionIds: selection.bundleVersionIds ?? [],
+      promoCode: selection.promoCode ?? null,
+      locale
+    });
+    await this.assertFeatureRequiresSatisfied({
+      planKey: selection.planKey,
+      planVersionId: priced.planVersionId,
+      bundleVersionIds: priced.bundleVersionIds,
+      lineItems: priced.lineItems
+    });
+    return this.repo.create({
+      planKey: selection.planKey,
+      billingCycle: selection.billingCycle,
+      locale,
+      validUntil: selection.validUntil ?? null,
+      ...priced
+    });
+  }
+  /**
+   * Customization in onboarding — only while the offer is `open`. The plan
+   * stays; whatever else changes, the whole offer is priced again. A slot of
+   * its promo code held for its checkout stays with it while the code does,
+   * and is given back when the code is changed or removed.
+   */
+  async update(id, change) {
+    const existing = await this.getById(id);
+    this.assertOpen(existing, "changed");
+    const billingCycle = change.billingCycle ?? existing.billingCycle;
+    const locale = change.locale ?? existing.locale;
+    const priced = await this.pricing.price({
+      planKey: existing.planKey,
+      billingCycle,
+      bundleVersionIds: change.bundleVersionIds ?? existing.bundleVersionIds ?? [],
+      promoCode: change.promoCode !== void 0 ? change.promoCode : existing.promoCode,
+      locale,
+      checkoutOfferId: id
+    });
+    await this.assertFeatureRequiresSatisfied({
+      planKey: existing.planKey,
+      planVersionId: priced.planVersionId,
+      bundleVersionIds: priced.bundleVersionIds,
+      lineItems: priced.lineItems
+    });
+    const codeChanges = priced.promoCode !== existing.promoCode;
+    const updated = await this.repo.update(id, {
+      billingCycle,
+      locale,
+      ...change.validUntil !== void 0 ? {
+        validUntil: change.validUntil
+      } : {},
+      ...priced
+    });
+    if (codeChanges) await this.promoCodes?.releaseCheckoutHold(id);
+    return updated;
+  }
+  /**
+   * Holds a slot of the offer's promo code for its checkout until `until` —
+   * what a sign-up does as its checkout starts, until a confirmation of its
+   * payment form can no longer arrive — so that the code cannot run out
+   * before the payment is confirmed and the offer concluded. A live slot the
+   * offer holds of that code already moves to `until`, never earlier. The
+   * conclusion turns the slot into the redemption; the slot goes back when
+   * the offer's code changes or `until` passes.
+   *
+   * Refused, and nothing held, when the offer is no longer open or its code
+   * cannot be held: `PROMO_CODE_NOT_REDEEMABLE` with the reason a preview
+   * gives, `EXHAUSTED` when every slot is redeemed or held. An offer without
+   * a code holds nothing.
+   */
+  async holdPromoCode(id, hold) {
+    for (let attempt = 0; attempt < HOLD_ATTEMPTS; attempt += 1) {
+      const offer = await this.getById(id);
+      this.assertOpen(offer, "held");
+      const code = offer.promoCode;
+      if (!code) {
+        await this.promoCodes?.releaseCheckoutHold(id);
+        return;
+      }
+      if (!this.promoCodes) {
+        throw new Error(`Checkout offer '${id}' carries a promo code and no promo module is registered to hold it: enable \`promoCodes\` in SaaSiCatModule.forRoot, or register PromoCodesModule globally beside CheckoutOfferModule.`);
+      }
+      await this.promoCodes.holdForCheckout({
+        checkoutOfferId: id,
+        code,
+        planId: offer.planKey,
+        billingCycle: offer.billingCycle === "yearly" ? "YEARLY" : "MONTHLY",
+        email: hold.email,
+        until: hold.until
+      });
+      if ((await this.getById(id)).promoCode === code) return;
+    }
+    await this.promoCodes?.releaseCheckoutHold(id);
+    throw offerChanged(id, "its promo code was being held");
+  }
+  /**
+   * Gives back the slot held for the offer's checkout while it is still held
+   * until `heldUntil`, as the caller wrote it. A slot another start of the
+   * checkout moved later stays with the form that start opened.
+   */
+  async releasePromoCodeHold(id, heldUntil) {
+    await this.promoCodes?.releaseCheckoutHoldIfUnmoved(id, heldUntil);
+  }
+  /**
+   * Freezes the offer (`status = 'consumed'`). Returns the final
+   * snapshot — the caller (registration/billing) writes it
+   * as `Subscription.packageSnapshot`.
+   *
+   * Refused unless every add-on is still bookable and the stored amounts are
+   * what the catalogue makes of the offer's own selection, so an offer whose
+   * amounts were written by anything but the pricing never becomes a contract.
+   *
+   * The plan, the add-ons and the promotions are priced as they stood when the
+   * offer was priced; a promo code is checked with the promo module as it
+   * stands now. A code is redeemed when the contract is concluded, so one that
+   * has expired or run out of redemptions since refuses the offer with
+   * `CHECKOUT_OFFER_PROMO_CODE_NOT_ACCEPTED`; `CHECKOUT_OFFER_PRICE_NOT_CURRENT`
+   * is kept for amounts that no longer match.
+   */
+  async consume(id) {
+    await this.assertConsumable(id);
+    return this.repo.consume(id);
+  }
+  /**
+   * Consumes an offer and creates its contract in one transaction, together
+   * with the application's own writes in `within`, so an offer is never
+   * consumed without its contract, and no contract is written for an offer
+   * that stays open.
+   *
+   * Everything that can refuse runs before the transaction: what `consume`
+   * checks, and the checks the contract the offer becomes is held to. Inside
+   * it, the offer is consumed on the condition that it is still open, the
+   * contract is written, and `within` runs; an error in any of them undoes
+   * the others, and the offer can be concluded again.
+   *
+   * An offer that is already concluded for the same tenant answers with its
+   * contract rather than a refusal, so a caller retrying after a lost answer,
+   * or losing a race to another call for that tenant, gets the conclusion that
+   * stands; `within` does not run again, its writes committed with it. A
+   * conclusion for another tenant is refused with
+   * `CHECKOUT_OFFER_ALREADY_CONSUMED`, and an offer changed between the checks
+   * and the transaction with `CHECKOUT_OFFER_CHANGED`, nothing written.
+   *
+   * The contract is between the tenant's subscriber and the configured
+   * issuer. A sign-up creates the tenant in `within` and has no subscriber
+   * yet, so it passes `subscriber`, which is created on the same transaction
+   * before the contract; whether one may be created, or whether the tenant
+   * has one, is asked before the transaction with the other checks.
+   *
+   * A promo code on the offer is redeemed in `within`, with
+   * `PromoCodesService.redeemInTransaction` on the same transaction. Before
+   * the transaction the code is only checked the way pricing checks it; the
+   * redemption checks the rest, the customer and the remaining redemptions,
+   * where a refusal still undoes everything. Nothing checks the code again
+   * after `within`, so a redemption that takes its last slot does not refuse
+   * the offer it was redeemed for.
+   *
+   * A slot held for the offer's checkout (`holdPromoCode`) is the offer's own
+   * throughout: the checks before the transaction do not count it against
+   * the code and accept the code as it stood when the slot was held, and the
+   * redemption in `within` takes that slot rather than a free one. A slot
+   * `within` did not redeem is given back before the conclusion commits.
+   */
+  async conclude(id, options, within) {
+    const { contracts, transactions, subscribers } = this.conclusionPorts();
+    const { subscriber, tx: callersTransaction, ...contractOptions } = options;
+    const { tenantId } = contractOptions;
+    const standing = await this.standingConclusion(await this.getById(id), contracts, tenantId);
+    if (standing) return standing;
+    const existing = await this.assertConsumable(id);
+    const checked = contracts.prepareFromOffer(existing, contractOptions);
+    await this.assertParty(subscribers, contracts, tenantId, subscriber);
+    let consumeFailed = false;
+    const concludeOn = /* @__PURE__ */ __name(async (tx) => {
+      consumeFailed = false;
+      let offer;
+      try {
+        offer = await this.repo.consume(id, tx);
+      } catch (error) {
+        consumeFailed = true;
+        throw error;
+      }
+      const data = contracts.createDataFromOffer(offer, contractOptions);
+      if (!isDeepStrictEqual(data, checked)) throw offerChanged(id);
+      if (subscriber) await subscribers.createForTenant(tenantId, subscriber, tx);
+      const contract = await contracts.create(data, tx);
+      const concluded = {
+        offer,
+        contract
+      };
+      const handedOver = await this.promoCodes?.handOverCheckoutHold(id, tx) ?? false;
+      if (within) await within(tx, concluded);
+      if (handedOver) await this.promoCodes?.releaseCheckoutHold(id, tx);
+      return concluded;
+    }, "concludeOn");
+    try {
+      return await (callersTransaction === void 0 ? transactions.run(concludeOn) : concludeOn(callersTransaction));
+    } catch (error) {
+      if (!consumeFailed) throw error;
+      const offer = await this.repo.findById(id).catch(() => null);
+      const concludedMeanwhile = await this.standingConclusion(offer, contracts, tenantId).catch(() => null);
+      if (concludedMeanwhile) return concludedMeanwhile;
+      throw error;
+    }
+  }
+  async assertConsumable(id) {
+    const existing = await this.getById(id);
+    this.assertOpen(existing, "consumed");
+    await this.assertBundleVersionsStillBookable(existing);
+    await this.pricing.assertPricedByCatalogue(existing);
+    return existing;
+  }
+  /**
+   * The conclusion that stands for this tenant, if the offer has one. An offer
+   * carries no tenant and its id travels in a link, so a conclusion for
+   * another tenant is not an answer: that caller is refused as before.
+   */
+  async standingConclusion(offer, contracts, tenantId) {
+    if (!offer || offer.status !== "consumed") return null;
+    const contract = await contracts.findByOriginalOfferId(offer.id);
+    return contract && contract.tenantId === tenantId ? {
+      offer,
+      contract
+    } : null;
+  }
+  conclusionPorts() {
+    if (!this.contracts || !this.transactions || !this.subscribers) {
+      throw new Error("CheckoutOfferService.conclude needs the subscription contract repository, the subscriber repository and a transaction runner: pass `conclusion` to CheckoutOfferModule.forRoot, or give SaaSiCatModule.forRoot a persistence bundle that has all three.");
+    }
+    return {
+      contracts: this.contracts,
+      transactions: this.transactions,
+      subscribers: this.subscribers
+    };
+  }
+  /**
+   * Before anything is written: the subscriber to create is one that may be
+   * created, or the tenant already has the party the contract is with.
+   */
+  async assertParty(subscribers, contracts, tenantId, subscriber) {
+    if (!subscriber) {
+      await contracts.assertPartyFor(tenantId);
+      return;
+    }
+    settleNewSubscriberDetails(subscriber);
+    if (await subscribers.findByTenantId(tenantId)) {
+      throw new ConflictException(codedError(SUBSCRIBER_ERROR_CODES.SUBSCRIBER_ALREADY_EXISTS, {
+        tenantId
+      }));
+    }
+  }
+  /**
+   * #35 P6 — server-side requires validation: the dependencies of all
+   * features (plan ∪ selected bundles) must be covered within the
+   * selection, otherwise an offer would be created whose features cannot
+   * work at the tenant (an app-specific validateModuleDependencies check is
+   * thereby replaced on the platform side). The requires source are the
+   * curated FeatureCatalogEntries; without CatalogEntryRepository it is
+   * skipped (graceful — no requires data available).
+   */
+  async assertFeatureRequiresSatisfied(input) {
+    if (!this.catalogEntries) return;
+    const entries = await this.catalogEntries.listFeatures({});
+    const requiresIndex = buildFeatureRequiresIndex(entries);
+    if (requiresIndex.size === 0) return;
+    const selected = /* @__PURE__ */ new Set([
+      ...await this.resolvePlanFeatures(input),
+      ...await this.resolveBundleFeatures(input)
+    ]);
+    const missingRequires = collectUnsatisfiedRequires([
+      ...selected
+    ], requiresIndex);
+    if (missingRequires.length > 0) {
+      throw new UnprocessableEntityException2({
+        code: CONTRACT_ERROR_CODES2.CHECKOUT_OFFER_FEATURE_DEPENDENCY_UNSATISFIED,
+        message: `The selected plan does not cover all feature dependencies: [${missingRequires.join(", ")}] are missing from the plan + selected bundles.`,
+        missingRequires
+      });
+    }
+  }
+  /**
+   * Plan features preferably from the server SSOT (PlanRepository); fallback
+   * is the frozen featuresSnapshot of the plan LineItem (adapter without
+   * PlanRepository wiring).
+   */
+  async resolvePlanFeatures(input) {
+    if (this.plans) {
+      const version = input.planVersionId ? await this.plans.findVersionById?.(input.planVersionId) : null;
+      const resolved = version ?? await this.plans.findActivePlanVersion?.(input.planKey) ?? await this.plans.findLatestLivePlanVersion?.(input.planKey);
+      if (resolved) return resolved.features ?? [];
+    }
+    return input.lineItems.filter((item) => item.kind === "plan").flatMap((item) => item.featuresSnapshot ?? []);
+  }
+  /** Bundle features from the BundleVersions; fallback featuresSnapshot. */
+  async resolveBundleFeatures(input) {
+    if (this.bundles) {
+      const features = [];
+      let allResolved = true;
+      for (const bundleVersionId of input.bundleVersionIds) {
+        const version = await this.bundles.findVersionById(bundleVersionId);
+        if (!version) {
+          allResolved = false;
+          break;
+        }
+        features.push(...version.features ?? []);
+      }
+      if (allResolved) return features;
+    }
+    return input.lineItems.filter((item) => item.kind === "bundle").flatMap((item) => item.featuresSnapshot ?? []);
+  }
+  async assertBundleVersionsStillBookable(offer) {
+    if (!this.bundles || !offer.bundleVersionIds || offer.bundleVersionIds.length === 0) {
+      return;
+    }
+    const now = Date.now();
+    const violations = [];
+    for (const bundleVersionId of offer.bundleVersionIds) {
+      const version = await this.bundles.findVersionById(bundleVersionId);
+      if (!version) {
+        violations.push({
+          bundleVersionId,
+          reason: "missing"
+        });
+        continue;
+      }
+      const reason = bundleVersionNotBookableReason(version, now);
+      if (reason) violations.push({
+        bundleVersionId,
+        reason
+      });
+    }
+    if (violations.length > 0) {
+      throw new UnprocessableEntityException2({
+        code: CONTRACT_ERROR_CODES2.CHECKOUT_OFFER_BUNDLE_VERSION_NOT_BOOKABLE,
+        message: "At least one bundle version from the checkout offer is no longer bookable.",
+        violations
+      });
+    }
+  }
+  assertOpen(existing, action) {
+    if (existing.status === "consumed") {
+      throw new ConflictException({
+        code: CONTRACT_ERROR_CODES2.CHECKOUT_OFFER_ALREADY_CONSUMED,
+        message: `Checkout offer '${existing.id}' has already been consumed and cannot be ${action}`,
+        params: {
+          offerId: existing.id,
+          action
+        }
+      });
+    }
+    if (existing.status === "expired") {
+      throw new ConflictException({
+        code: CONTRACT_ERROR_CODES2.CHECKOUT_OFFER_EXPIRED,
+        message: `Checkout offer '${existing.id}' has expired and cannot be ${action}`,
+        params: {
+          offerId: existing.id,
+          action,
+          validUntil: existing.validUntil ?? null
+        }
+      });
+    }
+    if (this.isExpired(existing)) {
+      throw new ConflictException({
+        code: CONTRACT_ERROR_CODES2.CHECKOUT_OFFER_EXPIRED,
+        message: `CheckoutOffer '${existing.id}' has expired and cannot be ${action}`,
+        params: {
+          offerId: existing.id,
+          action,
+          validUntil: existing.validUntil ?? null
+        }
+      });
+    }
+  }
+  isExpired(row) {
+    return isValidUntilExpired(row.validUntil, Date.now());
+  }
+};
+CheckoutOfferService = _ts_decorate2([
+  Injectable2(),
+  _ts_param2(0, Inject2(CHECKOUT_OFFER_REPOSITORY_TOKEN)),
+  _ts_param2(1, Inject2(CheckoutOfferPricing)),
+  _ts_param2(2, Optional2()),
+  _ts_param2(2, Inject2(BUNDLE_REPOSITORY_TOKEN)),
+  _ts_param2(3, Optional2()),
+  _ts_param2(3, Inject2(PLAN_REPOSITORY_TOKEN)),
+  _ts_param2(4, Optional2()),
+  _ts_param2(4, Inject2(CATALOG_ENTRY_REPOSITORY_TOKEN)),
+  _ts_param2(5, Optional2()),
+  _ts_param2(5, Inject2(SubscriptionContractService)),
+  _ts_param2(6, Optional2()),
+  _ts_param2(6, Inject2(CHECKOUT_OFFER_TRANSACTION_RUNNER_TOKEN)),
+  _ts_param2(7, Optional2()),
+  _ts_param2(7, Inject2(SubscriberService)),
+  _ts_param2(8, Optional2()),
+  _ts_param2(8, Inject2(PromoCodesService)),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof CheckoutOfferRepository === "undefined" ? Object : CheckoutOfferRepository,
+    typeof CheckoutOfferPricing === "undefined" ? Object : CheckoutOfferPricing,
+    Object,
+    Object,
+    Object,
+    Object,
+    Object,
+    Object,
+    Object
+  ])
+], CheckoutOfferService);
+function offerChanged(offerId, during = "it was being concluded") {
+  return new ConflictException({
+    code: CONTRACT_ERROR_CODES2.CHECKOUT_OFFER_CHANGED,
+    message: `Checkout offer '${offerId}' changed while ${during}. Load it again.`,
+    params: {
+      offerId
+    }
+  });
+}
+__name(offerChanged, "offerChanged");
+
+export {
+  CheckoutOfferPricing,
+  CHECKOUT_OFFER_REPOSITORY_TOKEN,
+  CHECKOUT_OFFER_TRANSACTION_RUNNER_TOKEN,
+  CheckoutOfferService
+};