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

package/dist/{chunk-M47BNEY2.js → chunk-7MLB6T5B.js}

@@ -1,22 +1,35 @@
+import {
+  AdminResourcesService
+} from "./chunk-5MZH3VVU.js";
 import {
   AdminAuditService
 } from "./chunk-OOTEXP47.js";
 import {
-  PromoCodesService
-} from "./chunk-3RLWML2S.js";
+  PromoCodesService,
+  buildLabel,
+  promoCodeDiscountNet
+} from "./chunk-QWKBOLBH.js";
 import {
-  SubscriptionContractService
-} from "./chunk-NDLC5GYK.js";
+  SUCCESSOR_ATTEMPTS,
+  SubscriptionContractService,
+  contractChanged,
+  generatedDiscountLine
+} from "./chunk-CVCKXKGT.js";
 import {
   resolveBundlePriceNet
 } from "./chunk-KPEMTBOP.js";
+import {
+  AllowDuringMaintenance
+} from "./chunk-TSLGMPGZ.js";
 import {
   EntitlementService,
   SUBSCRIPTION_BUNDLE_CONFIG_TOKEN,
   SUBSCRIPTION_BUNDLE_REPOSITORY_TOKEN,
   cancellationHasLanded,
+  contractBundleVersionIds,
+  contractLimits,
   toEffectiveLimitsSnapshot
-} from "./chunk-G6EZWECL.js";
+} from "./chunk-2XBWYMOL.js";
 import {
   ENTITLEMENT_SERVICE_TOKEN
 } from "./chunk-OUDSQ3PU.js";
@@ -29,8 +42,9 @@ import {
   planNotSoldInCycle
 } from "./chunk-TBBZWZQT.js";
 import {
+  CONTRACT_TRANSACTION_RUNNER_TOKEN,
   SUBSCRIPTION_CONTRACT_REPOSITORY_TOKEN
-} from "./chunk-VBRYPU7V.js";
+} from "./chunk-E224LKO2.js";
 import {
   assertContractWindow,
   assertNoNegativeDiscount,
@@ -44,6 +58,9 @@ import {
   CATALOG_ENTRY_REPOSITORY_TOKEN,
   PLAN_REPOSITORY_TOKEN
 } from "./chunk-3QVGA6JX.js";
+import {
+  DISCOVERY_SNAPSHOT_TOKEN
+} from "./chunk-QUZU2M33.js";
 import {
   ComposedTenantAuthGuard,
   holdsTenantAdminRole
@@ -61,9 +78,15 @@ import {
   USER_EMAIL_RESOLVER_TOKEN,
   USER_ID_RESOLVER_TOKEN
 } from "./chunk-GPQWGA6B.js";
+import {
+  RLS_BYPASS_PORT_TOKEN
+} from "./chunk-SZ7RFPXA.js";
 import {
   subscriberProviders
 } from "./chunk-WOEJ6K7M.js";
+import {
+  SUBSCRIBER_REPOSITORY_TOKEN
+} from "./chunk-LF6J4YYN.js";
 import {
   SaaSiCatPublicRoute
 } from "./chunk-YSC46BGM.js";
@@ -1028,23 +1051,52 @@ var SELF_SERVICE_BLOCKED_BUNDLES_TOKEN = /* @__PURE__ */ Symbol.for("saasicat/ne
 var DAY_MS2 = 864e5;
 function computeProration(input) {
   const { periodStart, periodEnd, now, currentPriceNet, targetPriceNet } = input;
-  const daysInPeriod = Math.max(1, Math.round((periodEnd.getTime() - periodStart.getTime()) / DAY_MS2));
-  const daysRemaining = Math.max(0, Math.min(daysInPeriod, Math.round((periodEnd.getTime() - now.getTime()) / DAY_MS2)));
+  const { daysInPeriod, daysRemaining } = daysOf(periodStart, periodEnd, now);
   const rawDeltaNet = round2((targetPriceNet - currentPriceNet) * daysRemaining / daysInPeriod);
-  const prorataDeltaNet = Math.max(0, rawDeltaNet);
   return {
+    basis: "difference",
     daysRemainingInPeriod: daysRemaining,
     daysInPeriod,
     periodStart,
     periodEnd,
     currentPriceNet,
     targetPriceNet,
-    prorataDeltaNet,
+    prorataDeltaNet: Math.max(0, rawDeltaNet),
     rawDeltaNet,
-    isFree: rawDeltaNet < 0
+    isFree: rawDeltaNet < 0,
+    remainderNet: 0
   };
 }
 __name(computeProration, "computeProration");
+function computeNewPeriodCharge(input) {
+  const { periodStart, periodEnd, now, currentPriceNet, targetPriceNet } = input;
+  const { daysInPeriod, daysRemaining } = daysOf(periodStart, periodEnd, now);
+  const remainderNet = round2(currentPriceNet * daysRemaining / daysInPeriod);
+  const rawDeltaNet = round2(targetPriceNet - remainderNet);
+  return {
+    basis: "newPeriod",
+    daysRemainingInPeriod: daysRemaining,
+    daysInPeriod,
+    periodStart,
+    periodEnd,
+    currentPriceNet,
+    targetPriceNet,
+    prorataDeltaNet: Math.max(0, rawDeltaNet),
+    rawDeltaNet,
+    isFree: rawDeltaNet < 0,
+    remainderNet
+  };
+}
+__name(computeNewPeriodCharge, "computeNewPeriodCharge");
+function daysOf(periodStart, periodEnd, now) {
+  const daysInPeriod = Math.max(1, Math.round((periodEnd.getTime() - periodStart.getTime()) / DAY_MS2));
+  const daysRemaining = Math.max(0, Math.min(daysInPeriod, Math.round((periodEnd.getTime() - now.getTime()) / DAY_MS2)));
+  return {
+    daysInPeriod,
+    daysRemaining
+  };
+}
+__name(daysOf, "daysOf");
 function round2(n) {
   return Math.round(n * 100) / 100;
 }
@@ -1081,7 +1133,8 @@ var PlanChangePreviewService = class {
   blockedPlans;
   trialProjection;
   subscriptionBundles;
-  constructor(catalogs, entitlements, subscriptions, usageSnapshot, blockedPlans = null, trialProjection = null, subscriptionBundles = null) {
+  contracts;
+  constructor(catalogs, entitlements, subscriptions, usageSnapshot, blockedPlans = null, trialProjection = null, subscriptionBundles = null, contracts = null) {
     this.catalogs = catalogs;
     this.entitlements = entitlements;
     this.subscriptions = subscriptions;
@@ -1089,6 +1142,7 @@ var PlanChangePreviewService = class {
     this.blockedPlans = blockedPlans;
     this.trialProjection = trialProjection;
     this.subscriptionBundles = subscriptionBundles;
+    this.contracts = contracts;
   }
   async preview(tenantId, targetPlan, targetCycle, now = /* @__PURE__ */ new Date()) {
     const sub = await this.subscriptions.findForTenant(tenantId);
@@ -1173,7 +1227,7 @@ var PlanChangePreviewService = class {
     const commits = ctx.status !== "TRIAL";
     const isImmediate = planDirection === "UP" && (!commits || cycleDirection !== "SHORTER");
     const effectiveAt = isImmediate ? null : this.resolveEffectiveAt(ctx, now);
-    const proration = isImmediate && ctx.status !== "TRIAL" ? this.computeProration(ctx, now, currentSnap, targetSnap, sub.billingCycle, targetCycle) : null;
+    const proration = isImmediate && ctx.status !== "TRIAL" ? this.computeProration(ctx, now, await this.planPricePaid(tenantId, sub.plan, sub.billingCycle, now) ?? priceForCycle(currentSnap, sub.billingCycle) ?? 0, priceForCycle(targetSnap, targetCycle) ?? 0, cycleDirection) : null;
     const blockers = [];
     const warnings = [];
     const landsAt = ctx.canceledEffectiveAt ?? ctx.canceledAt;
@@ -1360,17 +1414,41 @@ var PlanChangePreviewService = class {
     if (ctx.minimumTermUntil && ctx.minimumTermUntil > periodEnd) return ctx.minimumTermUntil;
     return periodEnd;
   }
-  computeProration(ctx, now, current, target, currentCycle, targetCycle) {
+  computeProration(ctx, now, currentPriceNet, targetPriceNet, cycleDirection) {
+    if (ctx.currentPeriodEnd === null) {
+      return computeNewPeriodCharge({
+        periodStart: now,
+        periodEnd: now,
+        now,
+        currentPriceNet,
+        targetPriceNet
+      });
+    }
     const periodStart = ctx.currentPeriodStart ?? ctx.startedAt ?? now;
-    const periodEnd = ctx.currentPeriodEnd ?? periodEndAfter(ctx.startedAt, ctx.currentBillingCycle, now);
-    return computeProration({
+    const charge = cycleDirection === "SAME" ? computeProration : computeNewPeriodCharge;
+    return charge({
       periodStart,
-      periodEnd,
+      periodEnd: ctx.currentPeriodEnd,
       now,
-      currentPriceNet: priceForCycle(current, currentCycle) ?? 0,
-      targetPriceNet: priceForCycle(target, targetCycle) ?? 0
+      currentPriceNet,
+      targetPriceNet
     });
   }
+  /**
+   * The net price of the plan line in the contract in force, when it is for
+   * `plan` billed in `cycle` — what the customer pays for the period they are
+   * in. Null without contracts, or where the line is for another plan or
+   * rhythm: a freeze is optional and does not stop the change it follows when
+   * it fails, so the contract in force can still describe the plan before.
+   * The caller then prices from the catalogue.
+   */
+  async planPricePaid(tenantId, plan, cycle, now) {
+    const contract = await this.contracts?.findActiveByTenantId(tenantId, now);
+    const planLine = contract?.lineItems.find((line) => line.kind === "plan");
+    if (!planLine || planLine.sourceKey !== plan) return null;
+    if (planLine.billingCycle !== cycle.toLowerCase()) return null;
+    return planLine.priceNet;
+  }
 };
 PlanChangePreviewService = _ts_decorate4([
   Injectable2(),
@@ -1384,6 +1462,8 @@ PlanChangePreviewService = _ts_decorate4([
   _ts_param2(5, Inject2(TRIAL_PROJECTION_PORT_TOKEN)),
   _ts_param2(6, Optional2()),
   _ts_param2(6, Inject2(SUBSCRIPTION_BUNDLE_REPOSITORY_TOKEN)),
+  _ts_param2(7, Optional2()),
+  _ts_param2(7, Inject2(SUBSCRIPTION_CONTRACT_REPOSITORY_TOKEN)),
   _ts_metadata2("design:type", Function),
   _ts_metadata2("design:paramtypes", [
     typeof PlanCatalogSource === "undefined" ? Object : PlanCatalogSource,
@@ -1392,6 +1472,7 @@ PlanChangePreviewService = _ts_decorate4([
     typeof UsageSnapshotPort === "undefined" ? Object : UsageSnapshotPort,
     Object,
     Object,
+    Object,
     Object
   ])
 ], PlanChangePreviewService);
@@ -1509,183 +1590,1710 @@ PendingPlanMaterializationService = _ts_decorate5([
   ])
 ], PendingPlanMaterializationService);
 
-// src/billing/subscription-contract-freeze.service.ts
-import { Inject as Inject4, Injectable as Injectable4, Optional as Optional4, UnprocessableEntityException } from "@nestjs/common";
-function _ts_decorate6(decorators, target, key, desc) {
+// src/billing/subscription-contract-freeze.service.ts
+import { Inject as Inject4, Injectable as Injectable4, Optional as Optional4, UnprocessableEntityException } from "@nestjs/common";
+function _ts_decorate6(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_decorate6, "_ts_decorate");
+function _ts_metadata4(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata4, "_ts_metadata");
+function _ts_param4(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param4, "_ts_param");
+var SubscriptionContractFreezeService = class {
+  static {
+    __name(this, "SubscriptionContractFreezeService");
+  }
+  catalogs;
+  entitlements;
+  contracts;
+  source;
+  subscriptions;
+  promoCodes;
+  constructor(catalogs, entitlements, contracts, source, writes = null, subscriptions = null, promoCodes = null) {
+    this.catalogs = catalogs;
+    this.entitlements = entitlements;
+    this.contracts = contracts;
+    this.source = source;
+    this.subscriptions = subscriptions;
+    this.promoCodes = promoCodes;
+    if (writes?.bindsPlanVersion === false) {
+      throw new Error("The contract freeze records the plan version a subscription is bound to, and this installation's subscription write does not bind it on a plan change. With @saasicat/adapter-prisma, leave `tenantSubscription.synchronizePlanVersion` at its default of true \u2014 or do not configure `contractFreeze`.");
+    }
+  }
+  assertPartyFor(tenantId) {
+    return this.contracts.assertPartyFor(tenantId);
+  }
+  async endOnCancellation(tenantId, effectiveAt) {
+    const active = await this.contracts.findActiveByTenantId(tenantId, effectiveAt);
+    if (!active) return;
+    await this.contracts.terminate(active.id, {
+      effectiveUntil: effectiveAt,
+      // Only when it is already over. An ordinary cancellation lands at
+      // the term end, months out, and the customer is under this contract
+      // until then — the invoice side has to keep finding it, and the
+      // window in `findActiveByTenantId` is what stops it afterwards.
+      status: effectiveAt <= /* @__PURE__ */ new Date() ? "terminated" : null
+    });
+    this.entitlements.invalidateTenant(tenantId);
+  }
+  async freezeOnPlanChange(tenantId, newPlan, billingCycle, effectiveFrom, endsAt = null) {
+    const data = await this.composeOnPlanChange(tenantId, newPlan, billingCycle, effectiveFrom, endsAt);
+    for (let attempt = 0; attempt < SUCCESSOR_ATTEMPTS; attempt++) {
+      const previous = await this.contracts.findActiveByTenantId(tenantId, effectiveFrom);
+      const written = await this.contracts.writeSuccessor(previous, data, effectiveFrom);
+      if (written) {
+        this.entitlements.invalidateTenant(tenantId);
+        return;
+      }
+    }
+    throw contractChanged(tenantId);
+  }
+  /**
+   * The contract `freezeOnPlanChange` would write, and nothing written: the
+   * plan version the subscription is bound to, the add-ons booked, the
+   * catalogue's rate and currency, and a promotional code not yet recorded —
+   * checked the way a contract is checked before it is written.
+   *
+   * Public so that an operator's refresh can show a full re-freeze before it
+   * makes one, measured by the same rules a plan change is.
+   */
+  async composeOnPlanChange(tenantId, newPlan, billingCycle, effectiveFrom, endsAt = null) {
+    const cycle = billingCycle === "YEARLY" ? "yearly" : "monthly";
+    const catalog = await this.catalogs.current();
+    const vatRate = catalog.vatRate;
+    assertTaxRatePercent("catalog.vatRate", vatRate);
+    assertContractWindow(effectiveFrom, endsAt);
+    const bound = await this.source.findBoundPlanVersion(tenantId);
+    if (!bound || bound.planId !== newPlan) {
+      throw new Error(`The contract for tenant ${tenantId} was asked to record plan '${newPlan}', but the subscription is bound to ${bound ? `'${bound.planId}' (version ${bound.id})` : "no plan version"}. Bind the plan version on the subscription before the contract is frozen.`);
+    }
+    const stem = findPlan(catalog, newPlan);
+    const planDef = planDefFromVersion({
+      id: newPlan,
+      name: stem?.name ?? newPlan,
+      tagline: stem?.tagline
+    }, bound);
+    if (isPlanNotSoldInCycle(planDef, billingCycle)) {
+      throw new UnprocessableEntityException(planNotSoldInCycle(planDef, billingCycle));
+    }
+    await this.contracts.assertPartyFor(tenantId);
+    const bundles = await this.source.loadBookedBundles(tenantId, cycle);
+    const planPriceNet = listPriceNet(planDef, billingCycle) ?? 0;
+    const planLineItem = {
+      kind: "plan",
+      sourceKey: newPlan,
+      sourceVersionId: bound.id,
+      titleSnapshot: planDef.name ?? newPlan,
+      descriptionSnapshot: planDef.tagline ?? null,
+      quantity: 1,
+      unit: null,
+      priceNet: planPriceNet,
+      billingCycle: cycle,
+      minimumTermUntil: null,
+      featuresSnapshot: planDef.features,
+      quotaEffectsSnapshot: planDef.quotas,
+      metadata: null
+    };
+    const redeemed = await this.redeemedCodeNotYetRecorded(tenantId, planPriceNet, billingCycle, vatRate);
+    const lineItems = recordContractLinesMoney([
+      planLineItem,
+      ...bundles.lineItems,
+      ...redeemed ? [
+        redeemed.line
+      ] : []
+    ], {
+      currency: catalog.currency,
+      taxRate: vatRate
+    });
+    const totals = contractTotalsOf(lineItems, cycle);
+    const priceSnapshot = {
+      currency: catalog.currency,
+      billingCycle: cycle,
+      subtotalNet: totals.subtotalNet,
+      discountNet: totals.discountNet,
+      totalNet: totals.totalNet,
+      vatRate,
+      totalGross: totals.totalGross
+    };
+    assertOnePlanLine(lineItems);
+    assertNoNegativeDiscount({
+      priceSnapshot
+    });
+    const { limits, leftOutBundleVersionIds } = await this.entitlements.computeContractLimits(tenantId, effectiveFrom, catalog);
+    const data = {
+      tenantId,
+      status: "active",
+      effectiveFrom,
+      // The successor inherits the ending. A cancellation capped the
+      // contract that was running when it was declared; every contract
+      // after it ends on the same date, or the repair lasts exactly until
+      // the next plan change.
+      effectiveUntil: endsAt,
+      originalPlanVersionId: bound.id,
+      originalBundleVersionIds: bundles.bundleVersionIds,
+      entitlementSnapshot: {
+        plan: limits.plan,
+        quotas: {
+          ...limits.quotas
+        },
+        features: [
+          ...limits.features
+        ],
+        ...leftOutBundleVersionIds.length > 0 ? {
+          leftOutBundleVersionIds
+        } : {}
+      },
+      priceSnapshot,
+      promoCodeSnapshots: redeemed ? [
+        redeemed.snapshot
+      ] : [],
+      lineItems
+    };
+    return data;
+  }
+  /**
+   * The code redeemed for the tenant's subscription, as a discount line, where
+   * no contract of the tenant records it yet.
+   *
+   * The first contract written after a redemption records it — at onboarding,
+   * or at the activation after a trial, where onboarding wrote none — and the
+   * ones after it do not repeat it: the discount runs from where it was first
+   * agreed, for the duration on its snapshot, counted from the first period
+   * that is paid. A contract concluded from an offer that carried the code
+   * already records it. Nothing is recorded without the promo module, for a
+   * reversed redemption, or where a contract written since the redemption
+   * does not record it: that was the first one, written before contracts
+   * recorded codes or by the application itself, and a later contract does
+   * not start the discount again.
+   */
+  async redeemedCodeNotYetRecorded(tenantId, planPriceNet, billingCycle, vatRate) {
+    if (!this.promoCodes || !this.subscriptions) return null;
+    const subscription = await this.subscriptions.findForTenant(tenantId);
+    if (!subscription?.id) return null;
+    const redeemed = await this.promoCodes.redeemedCodeFor(subscription.id);
+    if (!redeemed) return null;
+    const recorded = await this.contracts.list({
+      tenantId
+    });
+    if (recorded.some((contract) => recordsPromoCode(contract, redeemed.code) || contract.createdAt > redeemed.redeemedAt)) {
+      return null;
+    }
+    const cycle = billingCycle === "YEARLY" ? "yearly" : "monthly";
+    const snapshot = {
+      code: redeemed.code,
+      label: buildLabel(redeemed, billingCycle),
+      valueType: redeemed.valueType,
+      value: Number(redeemed.value),
+      resolvedAmountNet: promoCodeDiscountNet(planPriceNet, vatRate, redeemed),
+      durationType: redeemed.durationType,
+      durationValue: redeemed.durationValue
+    };
+    const line = generatedDiscountLine({
+      billingCycle: cycle,
+      promoCodeSnapshot: snapshot,
+      promotionSnapshots: []
+    }, snapshot.resolvedAmountNet);
+    return {
+      snapshot,
+      line: {
+        kind: line.kind,
+        sourceKey: line.sourceKey,
+        sourceVersionId: line.sourceVersionId ?? null,
+        titleSnapshot: line.titleSnapshot,
+        descriptionSnapshot: line.descriptionSnapshot ?? null,
+        quantity: line.quantity,
+        unit: line.unit ?? null,
+        priceNet: line.priceNet,
+        billingCycle: cycle,
+        minimumTermUntil: null,
+        featuresSnapshot: [],
+        quotaEffectsSnapshot: {},
+        metadata: line.metadata ?? null
+      }
+    };
+  }
+};
+SubscriptionContractFreezeService = _ts_decorate6([
+  Injectable4(),
+  _ts_param4(0, Inject4(PLAN_CATALOG_SOURCE_TOKEN)),
+  _ts_param4(1, Inject4(ENTITLEMENT_SERVICE_TOKEN)),
+  _ts_param4(2, Inject4(SubscriptionContractService)),
+  _ts_param4(3, Inject4(CONTRACT_FREEZE_SOURCE_PORT_TOKEN)),
+  _ts_param4(4, Optional4()),
+  _ts_param4(4, Inject4(SUBSCRIPTION_WRITE_PORT_TOKEN)),
+  _ts_param4(5, Optional4()),
+  _ts_param4(5, Inject4(SUBSCRIPTION_USAGE_PORT_TOKEN)),
+  _ts_param4(6, Optional4()),
+  _ts_param4(6, Inject4(PromoCodesService)),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
+    typeof PlanCatalogSource === "undefined" ? Object : PlanCatalogSource,
+    typeof EntitlementService === "undefined" ? Object : EntitlementService,
+    typeof SubscriptionContractService === "undefined" ? Object : SubscriptionContractService,
+    typeof ContractFreezeSourcePort === "undefined" ? Object : ContractFreezeSourcePort,
+    Object,
+    Object,
+    Object
+  ])
+], SubscriptionContractFreezeService);
+function recordsPromoCode(contract, code) {
+  return contract.promoCodeSnapshots.some((snapshot) => snapshot !== null && typeof snapshot === "object" && snapshot.code === code);
+}
+__name(recordsPromoCode, "recordsPromoCode");
+
+// src/billing/contract-refresh.ts
+var PRICE_FIELDS = [
+  "currency",
+  "billingCycle",
+  "vatRate",
+  "subtotalNet",
+  "discountNet",
+  "totalNet",
+  "totalGross"
+];
+var LINE_MONEY_FIELDS = [
+  "quantity",
+  "billingCycle",
+  "currency",
+  "taxRate",
+  "priceNet",
+  "priceGross",
+  "taxAmount"
+];
+function featureChangeOf(before, after) {
+  const was = new Set(before);
+  const is = new Set(after);
+  return {
+    added: [
+      ...is
+    ].filter((key) => !was.has(key)).sort(),
+    removed: [
+      ...was
+    ].filter((key) => !is.has(key)).sort()
+  };
+}
+__name(featureChangeOf, "featureChangeOf");
+function quotaChangesOf(before, after) {
+  const keys = [
+    .../* @__PURE__ */ new Set([
+      ...Object.keys(before),
+      ...Object.keys(after)
+    ])
+  ].sort();
+  return keys.map((key) => ({
+    key,
+    before: before[key] ?? null,
+    after: after[key] ?? null
+  })).filter((change) => change.before !== change.after);
+}
+__name(quotaChangesOf, "quotaChangesOf");
+function moneyChangesOf(contract, successor) {
+  const changes = [];
+  for (const field of PRICE_FIELDS) {
+    const before = contract.priceSnapshot[field];
+    const after = successor.priceSnapshot[field];
+    if (before !== after) changes.push({
+      field: `priceSnapshot.${field}`,
+      before,
+      after
+    });
+  }
+  const unmatched = [
+    ...successor.lineItems
+  ];
+  for (const line of contract.lineItems) {
+    const index = unmatched.findIndex((other2) => lineKeyOf(other2) === lineKeyOf(line));
+    if (index === -1) {
+      changes.push({
+        field: `line ${lineKeyOf(line)}`,
+        before: line.priceNet,
+        after: null
+      });
+      continue;
+    }
+    const [other] = unmatched.splice(index, 1);
+    changes.push(...lineMoneyChangesOf(line, other));
+  }
+  for (const other of unmatched) {
+    changes.push({
+      field: `line ${lineKeyOf(other)}`,
+      before: null,
+      after: other.priceNet
+    });
+  }
+  return changes;
+}
+__name(moneyChangesOf, "moneyChangesOf");
+function lineMoneyChangesOf(before, after) {
+  return LINE_MONEY_FIELDS.filter((field) => before[field] !== after[field]).map((field) => ({
+    field: `line ${lineKeyOf(before)} ${field}`,
+    before: before[field],
+    after: after[field]
+  }));
+}
+__name(lineMoneyChangesOf, "lineMoneyChangesOf");
+function lineKeyOf(line) {
+  return `${line.kind}:${line.sourceKey}`;
+}
+__name(lineKeyOf, "lineKeyOf");
+function withAgreedTerms(contract, successor) {
+  const unmatched = [
+    ...contract.lineItems
+  ];
+  return {
+    ...successor,
+    originalOfferId: contract.originalOfferId,
+    termsSnapshot: contract.termsSnapshot ? {
+      ...contract.termsSnapshot
+    } : null,
+    promotionSnapshots: [
+      ...contract.promotionSnapshots
+    ],
+    promoCodeSnapshots: [
+      ...contract.promoCodeSnapshots
+    ],
+    lineItems: successor.lineItems.map((line) => {
+      const index = unmatched.findIndex((agreed2) => lineKeyOf(agreed2) === lineKeyOf(line));
+      if (index === -1) return line;
+      const [agreed] = unmatched.splice(index, 1);
+      return {
+        ...line,
+        minimumTermUntil: agreed.minimumTermUntil
+      };
+    })
+  };
+}
+__name(withAgreedTerms, "withAgreedTerms");
+function vocabularyOf(input) {
+  return {
+    unknown: [
+      ...input.frozen
+    ].filter((key) => !input.known.has(key)).sort(),
+    missing: [
+      ...input.grantedToday
+    ].filter((key) => !input.frozenWithReplacements.has(key)).sort()
+  };
+}
+__name(vocabularyOf, "vocabularyOf");
+
+// src/billing/contract-refresh.service.ts
+import { Inject as Inject5, Injectable as Injectable5, Logger as Logger2, Optional as Optional5 } from "@nestjs/common";
+import { ACTIVE_SUBSCRIPTION_CONTRACT_STATUSES } from "@saasicat/core";
+function _ts_decorate7(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_decorate7, "_ts_decorate");
+function _ts_metadata5(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata5, "_ts_metadata");
+function _ts_param5(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param5, "_ts_param");
+var UNREADABLE = [
+  "NO_SUBSCRIPTION",
+  "REFUSED"
+];
+var NO_VOCABULARY = {
+  unknown: [],
+  missing: []
+};
+var ContractRefreshService = class {
+  static {
+    __name(this, "ContractRefreshService");
+  }
+  contracts;
+  entitlements;
+  usage;
+  catalogs;
+  freeze;
+  discovery;
+  rlsBypass;
+  audit;
+  logger = new Logger2("SaaSiCat.ContractRefresh");
+  constructor(contracts, entitlements, usage, catalogs, freeze, discovery = null, rlsBypass = null, audit = null) {
+    this.contracts = contracts;
+    this.entitlements = entitlements;
+    this.usage = usage;
+    this.catalogs = catalogs;
+    this.freeze = freeze;
+    this.discovery = discovery;
+    this.rlsBypass = rlsBypass;
+    this.audit = audit;
+  }
+  /** The contracts in force whose frozen features hold unknown keys or lack granted ones. */
+  inspect(asOf = /* @__PURE__ */ new Date()) {
+    return this.withBypass(async () => {
+      const previews = await this.previewAll({}, "features", asOf);
+      return {
+        inForce: previews.length,
+        stale: previews.filter(({ vocabulary }) => vocabulary.unknown.length > 0 || vocabulary.missing.length > 0),
+        unreadable: previews.filter(({ refusal }) => refusal !== null && UNREADABLE.includes(refusal.code))
+      };
+    });
+  }
+  /** What a refresh would change on each contract selected. Writes nothing. */
+  preview(selection, mode, asOf = /* @__PURE__ */ new Date()) {
+    return this.withBypass(() => this.previewAll(selection, mode, asOf));
+  }
+  /**
+   * Writes a successor for each contract selected that would change and is
+   * not refused, and keeps the contract it replaces as superseded
+   * (`SC-AUD-007`). What it writes is what `preview` shows at this moment.
+   */
+  apply(selection, mode, actor, asOf = /* @__PURE__ */ new Date()) {
+    return this.withBypass(async () => {
+      const catalog = await this.catalogs.current();
+      const outcomes = [];
+      for (const target of await this.targets(selection, asOf)) {
+        const planned = await this.plan(target, mode, catalog, asOf);
+        outcomes.push(await this.write(target, planned, mode, actor, asOf));
+      }
+      return outcomes;
+    });
+  }
+  // -----------------------------------------------------------------
+  async previewAll(selection, mode, asOf) {
+    const catalog = await this.catalogs.current();
+    const previews = [];
+    for (const target of await this.targets(selection, asOf)) {
+      previews.push((await this.plan(target, mode, catalog, asOf)).preview);
+    }
+    return previews;
+  }
+  async write(target, planned, mode, actor, asOf) {
+    const { preview, successor } = planned;
+    const unwritten = {
+      ...preview,
+      successorId: null,
+      moved: false
+    };
+    if (!target.contract || !successor || preview.refusal || !preview.changes) {
+      return unwritten;
+    }
+    let written;
+    try {
+      written = await this.contracts.writeSuccessor(target.contract, successor, asOf, {
+        keepParties: mode === "features"
+      });
+    } catch (error) {
+      return {
+        ...unwritten,
+        refusal: {
+          code: "REFUSED",
+          reason: messageOf(error)
+        }
+      };
+    }
+    if (!written) return {
+      ...unwritten,
+      moved: true
+    };
+    this.entitlements.invalidateTenant(written.tenantId);
+    await this.record(actor, target.contract, written, mode, preview);
+    return {
+      ...preview,
+      successorId: written.id,
+      moved: false
+    };
+  }
+  async plan(target, mode, catalog, asOf) {
+    const contract = target.contract;
+    if (!contract) {
+      return refused(target.contractId, target.found?.tenantId ?? null, NO_VOCABULARY, {
+        code: "NOT_IN_FORCE"
+      });
+    }
+    const frozen = contractLimits(contract);
+    const known = this.knownFeatures(catalog);
+    const unknownOnly = vocabularyOf({
+      frozen: frozen.features,
+      frozenWithReplacements: frozen.features,
+      grantedToday: /* @__PURE__ */ new Set(),
+      known
+    });
+    let today;
+    try {
+      today = await this.entitlements.contractFeaturesFor(contract.tenantId, contractBundleVersionIds(contract), catalog);
+    } catch (error) {
+      return refused(contract.id, contract.tenantId, unknownOnly, {
+        code: "REFUSED",
+        reason: messageOf(error)
+      });
+    }
+    if (!today) {
+      return refused(contract.id, contract.tenantId, unknownOnly, {
+        code: "NO_SUBSCRIPTION"
+      });
+    }
+    const grantedToday = today.features;
+    const vocabulary = vocabularyOf({
+      frozen: frozen.features,
+      frozenWithReplacements: this.entitlements.withReplacements(frozen.features),
+      grantedToday,
+      known
+    });
+    if (mode === "features") {
+      const recorded = recordedPlanVersionOf(contract);
+      if (!recorded) {
+        return refused(contract.id, contract.tenantId, vocabulary, {
+          code: "PLAN_VERSION_NOT_RECORDED"
+        });
+      }
+      if (recorded !== today.planVersionId) {
+        return refused(contract.id, contract.tenantId, vocabulary, {
+          code: "PLAN_VERSION_MOVED",
+          recorded,
+          bound: today.planVersionId
+        });
+      }
+      return this.compared(contract, frozen, vocabulary, {
+        ...this.contracts.dataOf(contract),
+        status: "active",
+        effectiveFrom: asOf,
+        entitlementSnapshot: {
+          plan: frozen.plan,
+          quotas: {
+            ...frozen.quotas
+          },
+          features: [
+            ...grantedToday
+          ].sort(),
+          ...leftOutOf(contract)
+        }
+      });
+    }
+    let successor;
+    try {
+      successor = await this.refrozen(contract, asOf);
+    } catch (error) {
+      return refused(contract.id, contract.tenantId, vocabulary, {
+        code: "REFUSED",
+        reason: messageOf(error)
+      });
+    }
+    const planned = this.compared(contract, frozen, vocabulary, successor);
+    if (planned.preview.money.length > 0) {
+      planned.preview.refusal = {
+        code: "MONEY_WOULD_CHANGE"
+      };
+    }
+    return planned;
+  }
+  /**
+   * The contract `freezeOnPlanChange` would write for the tenant now, with
+   * the terms the contract it replaces agreed.
+   */
+  async refrozen(contract, asOf) {
+    const subscription = await this.usage.findForTenant(contract.tenantId);
+    if (!subscription) throw new Error(`Tenant '${contract.tenantId}' has no subscription.`);
+    const composed = await this.freeze.composeOnPlanChange(
+      contract.tenantId,
+      subscription.plan,
+      // The column behind it is the `BillingCycle` enum in the canonical
+      // schema; the usage port types it as a string.
+      subscription.billingCycle,
+      asOf,
+      contract.effectiveUntil
+    );
+    return withAgreedTerms(contract, composed);
+  }
+  compared(contract, frozen, vocabulary, successor) {
+    const snapshot = successor.entitlementSnapshot;
+    const features = featureChangeOf(frozen.features, snapshot?.features ?? []);
+    const quotas = quotaChangesOf(frozen.quotas, snapshot?.quotas ?? {});
+    const money = moneyChangesOf(contract, successor);
+    const leftOutMoved = !sameMembers(contract.entitlementSnapshot?.leftOutBundleVersionIds ?? [], snapshot?.leftOutBundleVersionIds ?? []);
+    return {
+      preview: {
+        contractId: contract.id,
+        tenantId: contract.tenantId,
+        vocabulary,
+        features,
+        quotas,
+        money,
+        changes: features.added.length > 0 || features.removed.length > 0 || quotas.length > 0 || money.length > 0 || frozen.plan !== snapshot?.plan || leftOutMoved,
+        refusal: null
+      },
+      successor
+    };
+  }
+  /**
+   * Every feature key the application knows: the ones its code declares, the
+   * old keys those declarations say they replace, and the catalogue's.
+   */
+  knownFeatures(catalog) {
+    const known = /* @__PURE__ */ new Set();
+    for (const feature of this.discovery?.features ?? []) {
+      known.add(feature.featureKey);
+      for (const old of feature.replaces ?? []) known.add(old);
+    }
+    for (const feature of catalog.features ?? []) known.add(feature.key);
+    return known;
+  }
+  /** The contracts selected, each read as it stands, or `null` where it is not in force. */
+  async targets(selection, asOf) {
+    if (selection.contractIds === void 0) {
+      const inForce = await this.contracts.list({
+        asOf
+      });
+      return inForce.filter((contract) => isInForce(contract, asOf)).map((contract) => ({
+        contractId: contract.id,
+        found: contract,
+        contract
+      }));
+    }
+    const targets = [];
+    for (const contractId of selection.contractIds) {
+      const found = await this.contracts.findById(contractId);
+      targets.push({
+        contractId,
+        found,
+        contract: found && isInForce(found, asOf) ? found : null
+      });
+    }
+    return targets;
+  }
+  /** Best effort: the successor stands whether or not its record could be written (`SC-AUD-004`). */
+  async record(actor, previous, successor, mode, preview) {
+    if (!this.audit) return;
+    try {
+      await this.audit.log({
+        actor,
+        entity: "SubscriptionContract",
+        entityId: successor.id,
+        action: "SUBSCRIPTION_CONTRACT_REFRESH",
+        changes: {
+          mode,
+          supersedes: previous.id,
+          tenantId: successor.tenantId,
+          features: preview.features,
+          quotas: preview.quotas
+        }
+      });
+    } catch (error) {
+      this.logger.error(`The audit record of the refresh that wrote contract ${successor.id} could not be written; the successor itself was.`, error instanceof Error ? error.stack : String(error));
+    }
+  }
+  withBypass(read) {
+    return this.rlsBypass ? this.rlsBypass.runWithBypass(read) : read();
+  }
+};
+ContractRefreshService = _ts_decorate7([
+  Injectable5(),
+  _ts_param5(0, Inject5(SubscriptionContractService)),
+  _ts_param5(1, Inject5(ENTITLEMENT_SERVICE_TOKEN)),
+  _ts_param5(2, Inject5(SUBSCRIPTION_USAGE_PORT_TOKEN)),
+  _ts_param5(3, Inject5(PLAN_CATALOG_SOURCE_TOKEN)),
+  _ts_param5(4, Inject5(SubscriptionContractFreezeService)),
+  _ts_param5(5, Optional5()),
+  _ts_param5(5, Inject5(DISCOVERY_SNAPSHOT_TOKEN)),
+  _ts_param5(6, Optional5()),
+  _ts_param5(6, Inject5(RLS_BYPASS_PORT_TOKEN)),
+  _ts_param5(7, Optional5()),
+  _ts_param5(7, Inject5(AdminAuditService)),
+  _ts_metadata5("design:type", Function),
+  _ts_metadata5("design:paramtypes", [
+    typeof SubscriptionContractService === "undefined" ? Object : SubscriptionContractService,
+    typeof EntitlementService === "undefined" ? Object : EntitlementService,
+    typeof SubscriptionUsagePort === "undefined" ? Object : SubscriptionUsagePort,
+    typeof PlanCatalogSource === "undefined" ? Object : PlanCatalogSource,
+    typeof SubscriptionContractFreezeService === "undefined" ? Object : SubscriptionContractFreezeService,
+    Object,
+    Object,
+    Object
+  ])
+], ContractRefreshService);
+function refused(contractId, tenantId, vocabulary, refusal) {
+  return {
+    preview: {
+      contractId,
+      tenantId,
+      vocabulary,
+      features: {
+        added: [],
+        removed: []
+      },
+      quotas: [],
+      money: [],
+      changes: false,
+      refusal
+    },
+    successor: null
+  };
+}
+__name(refused, "refused");
+function leftOutOf(contract) {
+  const leftOut = contract.entitlementSnapshot?.leftOutBundleVersionIds;
+  return leftOut && leftOut.length > 0 ? {
+    leftOutBundleVersionIds: [
+      ...leftOut
+    ]
+  } : {};
+}
+__name(leftOutOf, "leftOutOf");
+function recordedPlanVersionOf(contract) {
+  return contract.originalPlanVersionId ?? contract.lineItems.find((line) => line.kind === "plan")?.sourceVersionId ?? null;
+}
+__name(recordedPlanVersionOf, "recordedPlanVersionOf");
+function isInForce(contract, asOf) {
+  return ACTIVE_SUBSCRIPTION_CONTRACT_STATUSES.includes(contract.status) && contract.effectiveFrom.getTime() <= asOf.getTime() && (contract.effectiveUntil === null || contract.effectiveUntil.getTime() > asOf.getTime());
+}
+__name(isInForce, "isInForce");
+function sameMembers(a, b) {
+  const left = new Set(a);
+  const right = new Set(b);
+  return left.size === right.size && [
+    ...left
+  ].every((id) => right.has(id));
+}
+__name(sameMembers, "sameMembers");
+function messageOf(error) {
+  if (error && typeof error === "object" && "getResponse" in error) {
+    const response = error.getResponse();
+    if (response && typeof response === "object" && "message" in response) {
+      return String(response.message);
+    }
+  }
+  return error instanceof Error ? error.message : String(error);
+}
+__name(messageOf, "messageOf");
+
+// src/billing/charges/subscriber-charge.tokens.ts
+var SUBSCRIBER_LEDGER_REPOSITORY_TOKEN = /* @__PURE__ */ Symbol.for("saasicat/nest/SubscriberLedgerRepository");
+
+// src/billing/charges/subscriber-account.service.ts
+import { Inject as Inject6, Injectable as Injectable6 } from "@nestjs/common";
+
+// src/billing/charges/subscriber-account.ts
+var SOURCE_ORDER = {
+  plan: 0,
+  bundle: 1,
+  discount: 2
+};
+function toWire(charge) {
+  return {
+    ...charge,
+    periodStart: charge.periodStart.toISOString(),
+    periodEnd: charge.periodEnd.toISOString(),
+    bookedAt: charge.bookedAt.toISOString(),
+    createdAt: charge.createdAt.toISOString()
+  };
+}
+__name(toWire, "toWire");
+function newestFirst(a, b) {
+  return b.bookedAt.getTime() - a.bookedAt.getTime() || b.periodStart.getTime() - a.periodStart.getTime() || SOURCE_ORDER[a.source] - SOURCE_ORDER[b.source] || a.id.localeCompare(b.id);
+}
+__name(newestFirst, "newestFirst");
+function accountViewOf(input) {
+  const titles = /* @__PURE__ */ new Map();
+  for (const contract of input.contracts) {
+    for (const line of contract.lineItems) titles.set(line.id, line.titleSnapshot);
+  }
+  const entries = [
+    ...input.charges
+  ].sort(newestFirst).map((charge) => ({
+    charge: toWire(charge),
+    title: titles.get(charge.contractLineItemId) ?? null
+  }));
+  const subscriber = input.subscriber;
+  return {
+    holder: subscriber ? {
+      id: subscriber.id,
+      customerNumber: subscriber.customerNumber,
+      legalName: subscriber.legalName
+    } : null,
+    entries
+  };
+}
+__name(accountViewOf, "accountViewOf");
+
+// src/billing/charges/subscriber-account.service.ts
+function _ts_decorate8(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_decorate8, "_ts_decorate");
+function _ts_metadata6(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata6, "_ts_metadata");
+function _ts_param6(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param6, "_ts_param");
+var SubscriberAccountService = class {
+  static {
+    __name(this, "SubscriberAccountService");
+  }
+  ledger;
+  contracts;
+  subscribers;
+  subscriptions;
+  constructor(ledger, contracts, subscribers, subscriptions) {
+    this.ledger = ledger;
+    this.contracts = contracts;
+    this.subscribers = subscribers;
+    this.subscriptions = subscriptions;
+  }
+  /** The account of the tenant's subscriber; empty while it has no subscription. */
+  async accountOf(tenantId) {
+    const [subscription, subscriber, contracts] = await Promise.all([
+      this.subscriptions.findForTenant(tenantId),
+      this.subscribers.findByTenantId(tenantId),
+      this.contracts.list({
+        tenantId
+      })
+    ]);
+    const charges = subscription?.id ? await this.ledger.listBySubscription(subscription.id) : [];
+    return accountViewOf({
+      subscriber,
+      charges,
+      contracts
+    });
+  }
+};
+SubscriberAccountService = _ts_decorate8([
+  Injectable6(),
+  _ts_param6(0, Inject6(SUBSCRIBER_LEDGER_REPOSITORY_TOKEN)),
+  _ts_param6(1, Inject6(SUBSCRIPTION_CONTRACT_REPOSITORY_TOKEN)),
+  _ts_param6(2, Inject6(SUBSCRIBER_REPOSITORY_TOKEN)),
+  _ts_param6(3, Inject6(SUBSCRIPTION_USAGE_PORT_TOKEN)),
+  _ts_metadata6("design:type", Function),
+  _ts_metadata6("design:paramtypes", [
+    typeof SubscriberLedgerRepository === "undefined" ? Object : SubscriberLedgerRepository,
+    typeof SubscriptionContractRepository === "undefined" ? Object : SubscriptionContractRepository,
+    typeof SubscriberRepository === "undefined" ? Object : SubscriberRepository,
+    typeof SubscriptionUsagePort === "undefined" ? Object : SubscriptionUsagePort
+  ])
+], SubscriberAccountService);
+
+// src/billing/charges/subscriber-account.module.ts
+import { Controller as Controller2, Get as Get2, Inject as Inject7, Module as Module2, Param, UseGuards } from "@nestjs/common";
+function _ts_decorate9(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_decorate9, "_ts_decorate");
+function _ts_metadata7(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata7, "_ts_metadata");
+function _ts_param7(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param7, "_ts_param");
+function buildSubscriberAccountController(guards) {
+  let GeneratedSubscriberAccountController = class GeneratedSubscriberAccountController {
+    static {
+      __name(this, "GeneratedSubscriberAccountController");
+    }
+    tenants;
+    accounts;
+    rlsBypass;
+    constructor(tenants, accounts, rlsBypass) {
+      this.tenants = tenants;
+      this.accounts = accounts;
+      this.rlsBypass = rlsBypass;
+    }
+    /**
+     * The charges of the tenant's subscriber. An operator's request is
+     * scoped to no tenant, so finding the tenant and reading its account
+     * both run outside any row-level policy the application keeps its
+     * tenants apart with.
+     */
+    chargesOf(slug) {
+      const read = /* @__PURE__ */ __name(async () => {
+        const tenant = await this.tenants.getTenantDetail(slug);
+        return this.accounts.accountOf(tenant.id);
+      }, "read");
+      return this.rlsBypass.runWithBypass(read);
+    }
+  };
+  _ts_decorate9([
+    Get2("tenants/:slug/charges"),
+    _ts_param7(0, Param("slug")),
+    _ts_metadata7("design:type", Function),
+    _ts_metadata7("design:paramtypes", [
+      String
+    ]),
+    _ts_metadata7("design:returntype", typeof Promise === "undefined" ? Object : Promise)
+  ], GeneratedSubscriberAccountController.prototype, "chargesOf", null);
+  GeneratedSubscriberAccountController = _ts_decorate9([
+    Controller2("admin"),
+    AllowDuringMaintenance(),
+    UseGuards(...guards),
+    _ts_param7(0, Inject7(AdminResourcesService)),
+    _ts_param7(1, Inject7(SubscriberAccountService)),
+    _ts_param7(2, Inject7(RLS_BYPASS_PORT_TOKEN)),
+    _ts_metadata7("design:type", Function),
+    _ts_metadata7("design:paramtypes", [
+      typeof AdminResourcesService === "undefined" ? Object : AdminResourcesService,
+      typeof SubscriberAccountService === "undefined" ? Object : SubscriberAccountService,
+      typeof RlsBypassPort === "undefined" ? Object : RlsBypassPort
+    ])
+  ], GeneratedSubscriberAccountController);
+  return GeneratedSubscriberAccountController;
+}
+__name(buildSubscriberAccountController, "buildSubscriberAccountController");
+var SubscriberAccountModule = class _SubscriberAccountModule {
+  static {
+    __name(this, "SubscriberAccountModule");
+  }
+  static forRoot(options) {
+    return {
+      module: _SubscriberAccountModule,
+      imports: options.imports,
+      controllers: [
+        buildSubscriberAccountController(options.guards)
+      ]
+    };
+  }
+};
+SubscriberAccountModule = _ts_decorate9([
+  Module2({})
+], SubscriberAccountModule);
+
+// src/billing/charges/subscriber-charge.service.ts
+import { Inject as Inject8, Injectable as Injectable7, Logger as Logger3, Optional as Optional6 } from "@nestjs/common";
+
+// src/billing/charges/charge-derivation.ts
+var PERIOD_ORIGINS = [
+  "activation",
+  "renewal",
+  "bundleBooking",
+  "planChange"
+];
+var MAX_CYCLES = 600;
+var CENTS = 100;
+function deriveDueCharges(input) {
+  const planCharges = derivePlanCharges(input);
+  const periods = [
+    ...writtenPlanPeriods(input),
+    ...planCharges.map(({ period }) => period)
+  ];
+  return [
+    ...planCharges.map(({ charge }) => charge),
+    ...deriveUpgradeDifferences(input, periods),
+    ...deriveDiscountCharges(input, planCharges, periods),
+    ...deriveBundleCharges(input, accountStart(input))
+  ];
+}
+__name(deriveDueCharges, "deriveDueCharges");
+function bookingsTheContractMisses(contracts, bookings, now) {
+  const inForce = contractInForce(contracts, now);
+  if (!inForce) return [];
+  return bookings.filter((booking) => inForce.effectiveFrom < booking.startedAt && booking.currentPeriodEnd !== null && (booking.canceledEffectiveAt === null || booking.canceledEffectiveAt > now) && !inForce.lineItems.some((item) => item.kind === "bundle" && item.sourceVersionId === booking.bundleVersionId));
+}
+__name(bookingsTheContractMisses, "bookingsTheContractMisses");
+function derivePlanCharges(input) {
+  const { subscription } = input;
+  if (subscription.status === "TRIAL") return [];
+  const window = windowOf(subscription.currentPeriodStart, subscription.currentPeriodEnd);
+  if (!window) return [];
+  const rhythm = rhythmOf(subscription.billingCycle);
+  const isPlanLine = /* @__PURE__ */ __name((item) => item.kind === "plan" && item.billingCycle === rhythm, "isPlanLine");
+  const replaced = periodReplacedBy(window, input);
+  if (replaced) return newPeriodAfterChange(input, window, replaced, isPlanLine);
+  const priced = periodsToCharge({
+    window,
+    from: lastPeriodEnd(input.written, "plan", subscription.id) ?? window.start,
+    cycle: subscription.billingCycle,
+    anchorDay: subscription.anchorDay,
+    input,
+    endsAt: subscription.endsAt
+  }).flatMap((period) => {
+    const found = lineFor(input.contracts, period, isPlanLine);
+    return found ? [
+      {
+        period,
+        ...found
+      }
+    ] : [];
+  });
+  const firstContract = earliest2(input.contracts);
+  const opensSubscription = /* @__PURE__ */ __name((period) => holds(period, subscription.startedAt) || holds(period, firstContract?.effectiveFrom ?? null), "opensSubscription");
+  return priced.map(({ period, contract, line }) => {
+    const charge = chargeOf(input, contract, line, {
+      origin: opensSubscription(period) ? "activation" : "renewal",
+      source: "plan",
+      sourceRef: subscription.id,
+      period,
+      amountNet: line.priceNet,
+      bookedAt: period.start
+    });
+    return {
+      charge,
+      period: {
+        charge,
+        rhythm
+      }
+    };
+  });
+}
+__name(derivePlanCharges, "derivePlanCharges");
+function periodReplacedBy(window, input) {
+  const whole = input.written.filter((charge) => isWholePlanPeriod(charge, input.written, input.subscription.id));
+  return whole.filter((charge) => charge.periodStart < window.start && window.start < charge.periodEnd).sort((a, b) => a.periodStart.getTime() - b.periodStart.getTime())[0] ?? null;
+}
+__name(periodReplacedBy, "periodReplacedBy");
+function newPeriodAfterChange(input, window, replaced, isPlanLine) {
+  const { subscription } = input;
+  if (!isChargeable(window, input, subscription.endsAt)) return [];
+  const found = lineFor(input.contracts, window, isPlanLine);
+  if (!found) return [];
+  const charge = chargeOf(input, found.contract, found.line, {
+    origin: "planChange",
+    source: "plan",
+    sourceRef: subscription.id,
+    period: window,
+    amountNet: computeNewPeriodCharge({
+      periodStart: replaced.periodStart,
+      periodEnd: replaced.periodEnd,
+      now: window.start,
+      currentPriceNet: pricePaidBefore(window.start, replaced, input.contracts),
+      targetPriceNet: found.line.priceNet
+    }).prorataDeltaNet,
+    bookedAt: window.start
+  });
+  return [
+    {
+      charge,
+      period: {
+        charge,
+        rhythm: rhythmOf(subscription.billingCycle)
+      }
+    }
+  ];
+}
+__name(newPeriodAfterChange, "newPeriodAfterChange");
+function pricePaidBefore(at, replaced, contracts) {
+  const chargedUnder = lineById(contracts, replaced.contractLineItemId);
+  const rhythm = chargedUnder?.billingCycle;
+  const before = contractInForce(contracts, new Date(at.getTime() - 1));
+  const line = before?.lineItems.find((item) => item.kind === "plan" && item.billingCycle === rhythm);
+  return line?.priceNet ?? chargedUnder?.priceNet ?? replaced.amountNet;
+}
+__name(pricePaidBefore, "pricePaidBefore");
+function deriveUpgradeDifferences(input, periods) {
+  const { subscription } = input;
+  const charges = [];
+  for (const { charge: period, rhythm } of periods) {
+    const isPlanLine = /* @__PURE__ */ __name((item) => item.kind === "plan" && item.billingCycle === rhythm, "isPlanLine");
+    for (const contract of input.contracts) {
+      const at = contract.effectiveFrom;
+      if (contract.status === "scheduled") continue;
+      if (!(period.periodStart < at && at < period.periodEnd)) continue;
+      if (!isChargeable({
+        start: at,
+        end: period.periodEnd
+      }, input, subscription.endsAt)) {
+        continue;
+      }
+      const line = contract.lineItems.find(isPlanLine);
+      const before = contractInForce(input.contracts, new Date(at.getTime() - 1));
+      const lineBefore = before?.lineItems.find(isPlanLine);
+      if (!line || !lineBefore) continue;
+      const difference = computeProration({
+        periodStart: period.periodStart,
+        periodEnd: period.periodEnd,
+        now: at,
+        currentPriceNet: lineBefore.priceNet,
+        targetPriceNet: line.priceNet
+      }).prorataDeltaNet;
+      if (difference <= 0) continue;
+      charges.push(chargeOf(input, contract, line, {
+        origin: "planChange",
+        source: "plan",
+        sourceRef: subscription.id,
+        period: {
+          start: at,
+          end: period.periodEnd
+        },
+        amountNet: difference,
+        bookedAt: at
+      }));
+    }
+  }
+  return charges;
+}
+__name(deriveUpgradeDifferences, "deriveUpgradeDifferences");
+function writtenPlanPeriods(input) {
+  return input.written.flatMap((charge) => {
+    if (!isWholePlanPeriod(charge, input.written, input.subscription.id)) return [];
+    const line = lineById(input.contracts, charge.contractLineItemId);
+    return line ? [
+      {
+        charge,
+        rhythm: line.billingCycle
+      }
+    ] : [];
+  });
+}
+__name(writtenPlanPeriods, "writtenPlanPeriods");
+function isWholePlanPeriod(charge, written, subscriptionId) {
+  if (charge.source !== "plan" || charge.sourceRef !== subscriptionId) return false;
+  if (!PERIOD_ORIGINS.includes(charge.origin)) return false;
+  return charge.origin !== "planChange" || !isDifference(charge, written);
+}
+__name(isWholePlanPeriod, "isWholePlanPeriod");
+function isDifference(charge, written) {
+  return written.some((other) => other.source === "plan" && other.sourceRef === charge.sourceRef && other.periodStart < charge.periodStart && sameInstant(other.periodEnd, charge.periodEnd));
+}
+__name(isDifference, "isDifference");
+function accountStart(input) {
+  const { subscription } = input;
+  const firstCharged = firstPlanPeriodStart(input.written, subscription.id);
+  if (firstCharged) return firstCharged;
+  if (subscription.status === "TRIAL") return null;
+  return windowOf(subscription.currentPeriodStart, subscription.currentPeriodEnd)?.start ?? null;
+}
+__name(accountStart, "accountStart");
+function deriveBundleCharges(input, accountBegins) {
+  if (!accountBegins) return [];
+  const { subscription } = input;
+  const anchorDay = subscription.anchorDay;
+  const charges = [];
+  for (const booking of input.bookings) {
+    const window = windowOf(booking.currentPeriodStart, booking.currentPeriodEnd);
+    if (!window) continue;
+    const cycle = booking.billingCycle ?? subscription.billingCycle;
+    const endsAt = earlierOf(booking.canceledEffectiveAt, subscription.endsAt);
+    const lastEnd = lastPeriodEnd(input.written, "bundle", booking.id);
+    const chainStart = laterOf(booking.startedAt, accountBegins);
+    const periods = lastEnd ? periodsToCharge({
+      window,
+      from: lastEnd,
+      cycle,
+      anchorDay,
+      input,
+      endsAt
+    }) : [
+      ...firstBundlePeriod(window, chainStart, cycle, anchorDay),
+      ...periodsToCharge({
+        window,
+        from: firstBoundaryAfter(window, chainStart, cycle, anchorDay),
+        cycle,
+        anchorDay,
+        input,
+        endsAt
+      })
+    ].filter((period) => isChargeable(period, input, endsAt));
+    for (const period of periods) {
+      const priced = lineFor(input.contracts, period, (item) => item.kind === "bundle" && item.sourceVersionId === booking.bundleVersionId);
+      if (!priced) continue;
+      const { contract, line } = priced;
+      charges.push(chargeOf(input, contract, line, {
+        origin: !lastEnd && sameInstant(period.start, chainStart) ? "bundleBooking" : "renewal",
+        source: "bundle",
+        sourceRef: booking.id,
+        period,
+        // Every period is charged for its share of the whole cycle
+        // it ends, which is all of it except for the short first
+        // one — the same arithmetic the preview quoted
+        // (`SC-BUN-003`, `SC-PRIC-002`).
+        amountNet: computeProration({
+          periodStart: bundleFirstPeriodStart(period.end, cycle, anchorDay),
+          periodEnd: period.end,
+          now: period.start,
+          currentPriceNet: 0,
+          targetPriceNet: line.priceNet
+        }).prorataDeltaNet,
+        bookedAt: period.start
+      }));
+    }
+  }
+  return charges;
+}
+__name(deriveBundleCharges, "deriveBundleCharges");
+function deriveDiscountCharges(input, due, periods) {
+  const { subscription } = input;
+  const charges = [];
+  for (const { contract, line } of discountsWhereAgreed(input.contracts)) {
+    const rhythm = line.billingCycle;
+    const cycle = rhythm === "yearly" ? "YEARLY" : "MONTHLY";
+    const first = firstPeriodConcludedFor(contract, periods);
+    if (!first) continue;
+    const anchorDay = rhythm === rhythmOf(subscription.billingCycle) ? subscription.anchorDay : first.getUTCDate();
+    const beganInItsRhythm = periods.some((period) => period.rhythm === rhythm && sameInstant(period.charge.periodStart, first));
+    const endedAt = beganInItsRhythm ? firstPeriodStart(periods.filter((period) => period.rhythm !== rhythm && period.charge.periodStart > first)) : first;
+    for (const { charge: planCharge, period } of due) {
+      const amount = endedAt && planCharge.periodStart > endedAt ? 0 : period.rhythm === rhythm ? discountInPeriod(line, first, planCharge.periodStart, cycle, anchorDay) : sameInstant(planCharge.periodStart, endedAt) ? (
+        // period, and no more than it costs.
+        Math.min(discountLeftAt(line, first, planCharge.periodStart, cycle, anchorDay), planCharge.amountNet)
+      ) : 0;
+      if (amount <= 0) continue;
+      charges.push(chargeOf(input, contract, line, {
+        origin: planCharge.origin,
+        source: "discount",
+        sourceRef: line.sourceKey,
+        period: {
+          start: planCharge.periodStart,
+          end: planCharge.periodEnd
+        },
+        amountNet: -amount,
+        bookedAt: planCharge.bookedAt
+      }));
+    }
+  }
+  return charges;
+}
+__name(deriveDiscountCharges, "deriveDiscountCharges");
+function discountInPeriod(line, first, periodStart, cycle, anchorDay) {
+  const index = cyclesBetween(first, periodStart, cycle, anchorDay);
+  return index === null ? 0 : discountFor(line, index, first, periodStart, anchorDay);
+}
+__name(discountInPeriod, "discountInPeriod");
+function discountLeftAt(line, first, at, cycle, anchorDay) {
+  let cents = 0;
+  let periodStart = first;
+  for (let index = 0; index < MAX_CYCLES; index++) {
+    const amount = discountFor(line, index, first, periodStart, anchorDay);
+    if (amount === 0) break;
+    if (periodStart >= at) cents += toCents(amount);
+    periodStart = advanceOneCycle(periodStart, cycle, anchorDay ?? void 0);
+  }
+  return cents / CENTS;
+}
+__name(discountLeftAt, "discountLeftAt");
+function discountsWhereAgreed(contracts) {
+  const agreed = /* @__PURE__ */ new Map();
+  for (const contract of [
+    ...contracts
+  ].sort(byEffectiveFrom)) {
+    for (const line of contract.lineItems) {
+      if (line.kind !== "discount" || agreed.has(line.sourceKey)) continue;
+      agreed.set(line.sourceKey, {
+        contract,
+        line
+      });
+    }
+  }
+  return [
+    ...agreed.values()
+  ];
+}
+__name(discountsWhereAgreed, "discountsWhereAgreed");
+function discountFor(line, index, first, periodStart, anchorDay) {
+  const snapshots = discountSnapshotsOf(line);
+  if (!snapshots) {
+    return index === 0 ? -line.priceNet : 0;
+  }
+  const withinMonths = /* @__PURE__ */ __name((months) => periodStart < monthsAfter(first, months, anchorDay), "withinMonths");
+  let cents = 0;
+  for (const promotion of snapshots.promotions) {
+    const months = promotionMonths(promotion.value);
+    const applies = promotion.type === "intro" || promotion.type === "freeMonths" ? months !== null && withinMonths(months) : index === 0;
+    if (applies) cents += toCents(promotion.resolvedAmountNet);
+  }
+  const code = snapshots.promoCode;
+  if (code) {
+    const applies = code.durationType === "MONTHS" ? withinMonths(code.durationValue ?? 0) : code.durationType === "BILLING_CYCLES" ? index < (code.durationValue ?? 0) : index === 0;
+    if (applies) cents += toCents(code.resolvedAmountNet);
+  }
+  return cents / CENTS;
+}
+__name(discountFor, "discountFor");
+function discountSnapshotsOf(line) {
+  const metadata = line.metadata;
+  if (!isRecord(metadata) || metadata.generated !== true) return null;
+  const promotions = Array.isArray(metadata.promotionSnapshots) ? metadata.promotionSnapshots.filter(isRecord).map((snapshot) => ({
+    type: typeof snapshot.type === "string" ? snapshot.type : "",
+    value: snapshot.value,
+    resolvedAmountNet: numberOr0(snapshot.resolvedAmountNet)
+  })) : [];
+  const code = isRecord(metadata.promoCodeSnapshot) ? metadata.promoCodeSnapshot : null;
+  return {
+    promotions,
+    promoCode: code ? {
+      durationType: typeof code.durationType === "string" ? code.durationType : null,
+      durationValue: typeof code.durationValue === "number" ? code.durationValue : null,
+      resolvedAmountNet: numberOr0(code.resolvedAmountNet)
+    } : null
+  };
+}
+__name(discountSnapshotsOf, "discountSnapshotsOf");
+function promotionMonths(value) {
+  if (typeof value === "number") return value;
+  if (isRecord(value) && typeof value.months === "number") return value.months;
+  return null;
+}
+__name(promotionMonths, "promotionMonths");
+function periodsToCharge(args) {
+  const { window, from, cycle, anchorDay, input, endsAt } = args;
+  const periods = [];
+  let start = from;
+  for (let step = 0; step < MAX_CYCLES && start < window.start; step++) {
+    const end = advanceOneCycle(start, cycle, anchorDay ?? void 0);
+    if (end > window.start) break;
+    periods.push({
+      start,
+      end
+    });
+    start = end;
+  }
+  if (from <= window.start) periods.push(window);
+  return periods.filter((period) => isChargeable(period, input, endsAt));
+}
+__name(periodsToCharge, "periodsToCharge");
+function isChargeable(period, input, endsAt) {
+  return period.start < period.end && period.start <= input.now && (!endsAt || period.start < endsAt);
+}
+__name(isChargeable, "isChargeable");
+function firstBoundaryAfter(window, start, cycle, anchorDay) {
+  if (window.start <= start) return window.end;
+  let boundary = window.start;
+  for (let step = 0; step < MAX_CYCLES; step++) {
+    const before = retreatOneCycle(boundary, cycle, anchorDay ?? void 0);
+    if (before <= start) break;
+    boundary = before;
+  }
+  return boundary;
+}
+__name(firstBoundaryAfter, "firstBoundaryAfter");
+function firstBundlePeriod(window, start, cycle, anchorDay) {
+  return [
+    {
+      start,
+      end: firstBoundaryAfter(window, start, cycle, anchorDay)
+    }
+  ];
+}
+__name(firstBundlePeriod, "firstBundlePeriod");
+function lastPeriodEnd(written, source, sourceRef) {
+  let last = null;
+  for (const charge of written) {
+    if (charge.source !== source || charge.sourceRef !== sourceRef) continue;
+    if (!PERIOD_ORIGINS.includes(charge.origin)) continue;
+    if (!last || charge.periodEnd > last) last = charge.periodEnd;
+  }
+  return last;
+}
+__name(lastPeriodEnd, "lastPeriodEnd");
+function firstPlanPeriodStart(written, subscriptionId) {
+  let first = null;
+  for (const charge of written) {
+    if (charge.source !== "plan" || charge.sourceRef !== subscriptionId) continue;
+    if (!PERIOD_ORIGINS.includes(charge.origin)) continue;
+    if (!first || charge.periodStart < first) first = charge.periodStart;
+  }
+  return first;
+}
+__name(firstPlanPeriodStart, "firstPlanPeriodStart");
+function firstPeriodConcludedFor(concluded, periods) {
+  const at = concluded.effectiveFrom;
+  let first = null;
+  for (const { charge } of periods) {
+    if (charge.periodEnd <= at) continue;
+    if (charge.periodStart < at && charge.contractId !== concluded.id) continue;
+    if (!first || charge.periodStart < first) first = charge.periodStart;
+  }
+  return first;
+}
+__name(firstPeriodConcludedFor, "firstPeriodConcludedFor");
+function cyclesBetween(from, to, cycle, anchorDay) {
+  let at = from;
+  for (let step = 0; step < MAX_CYCLES; step++) {
+    if (at.getTime() === to.getTime()) return step;
+    if (at > to) return null;
+    at = advanceOneCycle(at, cycle, anchorDay ?? void 0);
+  }
+  return null;
+}
+__name(cyclesBetween, "cyclesBetween");
+function monthsAfter(from, months, anchorDay) {
+  let at = from;
+  for (let step = 0; step < months; step++) {
+    at = advanceOneCycle(at, "MONTHLY", anchorDay ?? from.getUTCDate());
+  }
+  return at;
+}
+__name(monthsAfter, "monthsAfter");
+function lineFor(contracts, period, matches) {
+  const inForce = contractInForce(contracts, period.start);
+  const inForceLine = inForce?.lineItems.find(matches);
+  if (inForce && inForceLine) return {
+    contract: inForce,
+    line: inForceLine
+  };
+  for (const contract of [
+    ...contracts
+  ].sort(byEffectiveFrom)) {
+    if (contract.status === "scheduled") continue;
+    if (contract.effectiveFrom < period.start || contract.effectiveFrom >= period.end) continue;
+    const line = contract.lineItems.find(matches);
+    if (line) return {
+      contract,
+      line
+    };
+  }
+  return null;
+}
+__name(lineFor, "lineFor");
+function contractInForce(contracts, at) {
+  return [
+    ...contracts
+  ].filter((contract) => contract.status !== "scheduled" && contract.effectiveFrom <= at && (contract.effectiveUntil === null || at < contract.effectiveUntil)).sort(byEffectiveFrom).at(-1) ?? null;
+}
+__name(contractInForce, "contractInForce");
+function earliest2(contracts) {
+  return [
+    ...contracts
+  ].sort(byEffectiveFrom)[0] ?? null;
+}
+__name(earliest2, "earliest");
+function byEffectiveFrom(a, b) {
+  return a.effectiveFrom.getTime() - b.effectiveFrom.getTime();
+}
+__name(byEffectiveFrom, "byEffectiveFrom");
+function chargeOf(input, contract, line, charge) {
+  return {
+    subscriberId: input.subscriberId,
+    tenantId: input.subscription.tenantId,
+    subscriptionId: input.subscription.id,
+    contractId: contract.id,
+    contractLineItemId: line.id,
+    origin: charge.origin,
+    source: charge.source,
+    sourceRef: charge.sourceRef,
+    periodStart: charge.period.start,
+    periodEnd: charge.period.end,
+    currency: line.currency,
+    // Rounded once, here, where it is derived (`SC-PRIC-018`).
+    amountNet: toCents(charge.amountNet) / CENTS,
+    bookedAt: charge.bookedAt
+  };
+}
+__name(chargeOf, "chargeOf");
+function windowOf(start, end) {
+  return start && end && start < end ? {
+    start,
+    end
+  } : null;
+}
+__name(windowOf, "windowOf");
+function laterOf(a, b) {
+  return b > a ? b : a;
+}
+__name(laterOf, "laterOf");
+function sameInstant(a, b) {
+  return b !== null && a.getTime() === b.getTime();
+}
+__name(sameInstant, "sameInstant");
+function firstPeriodStart(periods) {
+  return periods.reduce((first, { charge }) => !first || charge.periodStart < first ? charge.periodStart : first, null);
+}
+__name(firstPeriodStart, "firstPeriodStart");
+function holds(period, at) {
+  return at !== null && period.start <= at && at < period.end;
+}
+__name(holds, "holds");
+function earlierOf(a, b) {
+  if (!a) return b;
+  if (!b) return a;
+  return a < b ? a : b;
+}
+__name(earlierOf, "earlierOf");
+function rhythmOf(cycle) {
+  return cycle === "YEARLY" ? "yearly" : "monthly";
+}
+__name(rhythmOf, "rhythmOf");
+function lineById(contracts, id) {
+  for (const contract of contracts) {
+    const line = contract.lineItems.find((item) => item.id === id);
+    if (line) return line;
+  }
+  return null;
+}
+__name(lineById, "lineById");
+function toCents(amount) {
+  return Math.round(amount * CENTS);
+}
+__name(toCents, "toCents");
+function numberOr0(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+__name(numberOr0, "numberOr0");
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+__name(isRecord, "isRecord");
+
+// src/billing/charges/subscriber-charge.service.ts
+function _ts_decorate10(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_decorate6, "_ts_decorate");
-function _ts_metadata4(k, v) {
+__name(_ts_decorate10, "_ts_decorate");
+function _ts_metadata8(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata4, "_ts_metadata");
-function _ts_param4(paramIndex, decorator) {
+__name(_ts_metadata8, "_ts_metadata");
+function _ts_param8(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param4, "_ts_param");
-var SubscriptionContractFreezeService = class {
+__name(_ts_param8, "_ts_param");
+function planCycleOf(subscription) {
+  return subscription.billingCycle;
+}
+__name(planCycleOf, "planCycleOf");
+function endOf(subscription) {
+  return subscription.canceledEffectiveAt ?? subscription.canceledAt ?? null;
+}
+__name(endOf, "endOf");
+var SubscriberChargeService = class _SubscriberChargeService {
   static {
-    __name(this, "SubscriptionContractFreezeService");
+    __name(this, "SubscriberChargeService");
   }
-  catalogs;
-  entitlements;
+  ledger;
   contracts;
-  source;
-  constructor(catalogs, entitlements, contracts, source, writes = null) {
-    this.catalogs = catalogs;
-    this.entitlements = entitlements;
+  subscribers;
+  subscriptions;
+  bookings;
+  freeze;
+  logger = new Logger3(_SubscriberChargeService.name);
+  constructor(ledger, contracts, subscribers, subscriptions, bookings = null, freeze = null) {
+    this.ledger = ledger;
     this.contracts = contracts;
-    this.source = source;
-    if (writes?.bindsPlanVersion === false) {
-      throw new Error("The contract freeze records the plan version a subscription is bound to, and this installation's subscription write does not bind it on a plan change. With @saasicat/adapter-prisma, leave `tenantSubscription.synchronizePlanVersion` at its default of true \u2014 or do not configure `contractFreeze`.");
-    }
-  }
-  assertPartyFor(tenantId) {
-    return this.contracts.assertPartyFor(tenantId);
+    this.subscribers = subscribers;
+    this.subscriptions = subscriptions;
+    this.bookings = bookings;
+    this.freeze = freeze;
   }
-  async endOnCancellation(tenantId, effectiveAt) {
-    const active = await this.contracts.findActiveByTenantId(tenantId, effectiveAt);
-    if (!active) return;
-    await this.contracts.terminate(active.id, {
-      effectiveUntil: effectiveAt,
-      // Only when it is already over. An ordinary cancellation lands at
-      // the term end, months out, and the customer is under this contract
-      // until then — the invoice side has to keep finding it, and the
-      // window in `findActiveByTenantId` is what stops it afterwards.
-      status: effectiveAt <= /* @__PURE__ */ new Date() ? "terminated" : null
+  /**
+   * Writes every charge the tenant's records give rise to by `now` that is
+   * not written yet, and returns those.
+   *
+   * Nothing is charged without a contract (a charge points at a contract
+   * line), in a trial, before the plan's current window when the account is
+   * still empty, for a period that starts after `now`, or for one that
+   * starts on or after the date a cancellation takes effect.
+   *
+   * A window that moved on before anything charged it is not charged
+   * afterwards, so a job that renews periods calls this before it moves a
+   * window, and moves it only when the call succeeded.
+   */
+  async recordDueCharges(tenantId, now = /* @__PURE__ */ new Date()) {
+    const subscription = await this.subscriptions.findForTenant(tenantId);
+    if (!subscription?.id) return [];
+    const subscriber = await this.subscribers.findByTenantId(tenantId);
+    if (!subscriber) return [];
+    const [bookings, written] = await Promise.all([
+      this.bookings?.listBySubscription(subscription.id) ?? [],
+      this.ledger.listBySubscription(subscription.id)
+    ]);
+    const contracts = await this.contractsNamingEveryBooking(tenantId, subscription, bookings, now);
+    const due = deriveDueCharges({
+      now,
+      subscriberId: subscriber.id,
+      subscription: {
+        id: subscription.id,
+        tenantId,
+        status: subscription.status,
+        billingCycle: planCycleOf(subscription),
+        currentPeriodStart: subscription.currentPeriodStart,
+        currentPeriodEnd: subscription.currentPeriodEnd,
+        anchorDay: resolvePlanAnchorDay(subscription),
+        startedAt: subscription.startedAt,
+        endsAt: endOf(subscription)
+      },
+      contracts,
+      bookings,
+      written
     });
-    this.entitlements.invalidateTenant(tenantId);
+    return this.ledger.recordCharges(due);
   }
-  async freezeOnPlanChange(tenantId, newPlan, billingCycle, effectiveFrom, endsAt = null) {
-    const cycle = billingCycle === "YEARLY" ? "yearly" : "monthly";
-    const catalog = await this.catalogs.current();
-    const vatRate = catalog.vatRate;
-    assertTaxRatePercent("catalog.vatRate", vatRate);
-    assertContractWindow(effectiveFrom, endsAt);
-    const bound = await this.source.findBoundPlanVersion(tenantId);
-    if (!bound || bound.planId !== newPlan) {
-      throw new Error(`The contract for tenant ${tenantId} was asked to record plan '${newPlan}', but the subscription is bound to ${bound ? `'${bound.planId}' (version ${bound.id})` : "no plan version"}. Bind the plan version on the subscription before the contract is frozen.`);
+  /**
+   * The tenant's contracts, written once more where the one in force misses
+   * a running booking.
+   *
+   * A booking writes its contract after it is saved, and a failure there does
+   * not undo the booking. The booking would then stay uncharged for good,
+   * since a charge points at a contract line — so the journal writes the
+   * contract the way the booking would have. A failure here is logged and the
+   * rest is charged: the next call tries again.
+   */
+  async contractsNamingEveryBooking(tenantId, subscription, bookings, now) {
+    const contracts = await this.contracts.list({
+      tenantId
+    });
+    const missed = bookingsTheContractMisses(contracts, bookings, now);
+    if (missed.length === 0 || !this.freeze || subscription.status === "TRIAL" || cancellationHasLanded(subscription, now)) {
+      return contracts;
     }
-    const stem = findPlan(catalog, newPlan);
-    const planDef = planDefFromVersion({
-      id: newPlan,
-      name: stem?.name ?? newPlan,
-      tagline: stem?.tagline
-    }, bound);
-    if (isPlanNotSoldInCycle(planDef, billingCycle)) {
-      throw new UnprocessableEntityException(planNotSoldInCycle(planDef, billingCycle));
+    try {
+      await this.freeze.freezeOnPlanChange(tenantId, subscription.planVersion.planId, planCycleOf(subscription), now, endOf(subscription));
+    } catch (err) {
+      this.logger.error(`Writing the contract for ${missed.length} booking(s) it misses failed (tenant ${tenantId}): ${String(err)}`);
+      return contracts;
     }
-    await this.contracts.assertPartyFor(tenantId);
-    const bundles = await this.source.loadBookedBundles(tenantId, cycle);
-    const planPriceNet = listPriceNet(planDef, billingCycle) ?? 0;
-    const planLineItem = {
-      kind: "plan",
-      sourceKey: newPlan,
-      sourceVersionId: bound.id,
-      titleSnapshot: planDef.name ?? newPlan,
-      descriptionSnapshot: planDef.tagline ?? null,
-      quantity: 1,
-      unit: null,
-      priceNet: planPriceNet,
-      billingCycle: cycle,
-      minimumTermUntil: null,
-      featuresSnapshot: planDef.features,
-      quotaEffectsSnapshot: planDef.quotas,
-      metadata: null
-    };
-    const lineItems = recordContractLinesMoney([
-      planLineItem,
-      ...bundles.lineItems
-    ], {
-      currency: catalog.currency,
-      taxRate: vatRate
-    });
-    const totals = contractTotalsOf(lineItems, cycle);
-    const priceSnapshot = {
-      currency: catalog.currency,
-      billingCycle: cycle,
-      subtotalNet: totals.subtotalNet,
-      discountNet: totals.discountNet,
-      totalNet: totals.totalNet,
-      vatRate,
-      totalGross: totals.totalGross
-    };
-    assertOnePlanLine(lineItems);
-    assertNoNegativeDiscount({
-      priceSnapshot
+    return this.contracts.list({
+      tenantId
     });
-    const previous = await this.contracts.findActiveByTenantId(tenantId, effectiveFrom);
-    if (previous) {
-      await this.contracts.terminate(previous.id, {
-        effectiveUntil: effectiveFrom,
-        status: "superseded"
-      });
-    }
-    this.entitlements.invalidateTenant(tenantId);
-    const limits = await this.entitlements.computeLimits(tenantId, effectiveFrom, catalog);
-    const data = {
-      tenantId,
-      status: "active",
-      effectiveFrom,
-      // The successor inherits the ending. A cancellation capped the
-      // contract that was running when it was declared; every contract
-      // after it ends on the same date, or the repair lasts exactly until
-      // the next plan change.
-      effectiveUntil: endsAt,
-      originalPlanVersionId: bound.id,
-      originalBundleVersionIds: bundles.bundleVersionIds,
-      entitlementSnapshot: {
-        plan: limits.plan,
-        quotas: {
-          ...limits.quotas
-        },
-        features: [
-          ...limits.features
-        ]
-      },
-      priceSnapshot,
-      lineItems
-    };
-    await this.contracts.create(data);
-    this.entitlements.invalidateTenant(tenantId);
   }
 };
-SubscriptionContractFreezeService = _ts_decorate6([
-  Injectable4(),
-  _ts_param4(0, Inject4(PLAN_CATALOG_SOURCE_TOKEN)),
-  _ts_param4(1, Inject4(ENTITLEMENT_SERVICE_TOKEN)),
-  _ts_param4(2, Inject4(SubscriptionContractService)),
-  _ts_param4(3, Inject4(CONTRACT_FREEZE_SOURCE_PORT_TOKEN)),
-  _ts_param4(4, Optional4()),
-  _ts_param4(4, Inject4(SUBSCRIPTION_WRITE_PORT_TOKEN)),
-  _ts_metadata4("design:type", Function),
-  _ts_metadata4("design:paramtypes", [
-    typeof PlanCatalogSource === "undefined" ? Object : PlanCatalogSource,
-    typeof EntitlementService === "undefined" ? Object : EntitlementService,
-    typeof SubscriptionContractService === "undefined" ? Object : SubscriptionContractService,
-    typeof ContractFreezeSourcePort === "undefined" ? Object : ContractFreezeSourcePort,
+SubscriberChargeService = _ts_decorate10([
+  Injectable7(),
+  _ts_param8(0, Inject8(SUBSCRIBER_LEDGER_REPOSITORY_TOKEN)),
+  _ts_param8(1, Inject8(SUBSCRIPTION_CONTRACT_REPOSITORY_TOKEN)),
+  _ts_param8(2, Inject8(SUBSCRIBER_REPOSITORY_TOKEN)),
+  _ts_param8(3, Inject8(SUBSCRIPTION_USAGE_PORT_TOKEN)),
+  _ts_param8(4, Optional6()),
+  _ts_param8(4, Inject8(SUBSCRIPTION_BUNDLE_REPOSITORY_TOKEN)),
+  _ts_param8(5, Optional6()),
+  _ts_param8(5, Inject8(CONTRACT_FREEZE_PORT_TOKEN)),
+  _ts_metadata8("design:type", Function),
+  _ts_metadata8("design:paramtypes", [
+    typeof SubscriberLedgerRepository === "undefined" ? Object : SubscriberLedgerRepository,
+    typeof SubscriptionContractRepository === "undefined" ? Object : SubscriptionContractRepository,
+    typeof SubscriberRepository === "undefined" ? Object : SubscriberRepository,
+    typeof SubscriptionUsagePort === "undefined" ? Object : SubscriptionUsagePort,
+    Object,
     Object
   ])
-], SubscriptionContractFreezeService);
+], SubscriberChargeService);
 
 // src/billing/dto/tenant-billing.dto.ts
 import { IsISO8601, IsOptional, IsString, Matches } from "class-validator";
-function _ts_decorate7(decorators, target, key, desc) {
+function _ts_decorate11(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_decorate7, "_ts_decorate");
-function _ts_metadata5(k, v) {
+__name(_ts_decorate11, "_ts_decorate");
+function _ts_metadata9(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata5, "_ts_metadata");
+__name(_ts_metadata9, "_ts_metadata");
 var PLAN_OR_CYCLE_PATTERN = /^[A-Z][A-Z0-9_]*$/;
 var PreviewPlanChangeDto = class {
   static {
@@ -1694,19 +3302,19 @@ var PreviewPlanChangeDto = class {
   plan;
   billingCycle;
 };
-_ts_decorate7([
+_ts_decorate11([
   IsString(),
   Matches(PLAN_OR_CYCLE_PATTERN, {
     message: "plan must be SCREAMING_SNAKE_CASE"
   }),
-  _ts_metadata5("design:type", String)
+  _ts_metadata9("design:type", String)
 ], PreviewPlanChangeDto.prototype, "plan", void 0);
-_ts_decorate7([
+_ts_decorate11([
   IsString(),
   Matches(PLAN_OR_CYCLE_PATTERN, {
     message: "billingCycle must be SCREAMING_SNAKE_CASE (e.g. MONTHLY, YEARLY)"
   }),
-  _ts_metadata5("design:type", String)
+  _ts_metadata9("design:type", String)
 ], PreviewPlanChangeDto.prototype, "billingCycle", void 0);
 var ChangePlanDto = class extends PreviewPlanChangeDto {
   static {
@@ -1731,25 +3339,25 @@ var CancelSubscriptionDto = class {
    */
   expectedEffectiveAt;
 };
-_ts_decorate7([
+_ts_decorate11([
   IsOptional(),
   IsISO8601(),
-  _ts_metadata5("design:type", String)
+  _ts_metadata9("design:type", String)
 ], CancelSubscriptionDto.prototype, "expectedEffectiveAt", void 0);
 
 // src/billing/dto/onboarding-subscription.dto.ts
 import { ArrayMaxSize, IsArray, IsOptional as IsOptional2, IsString as IsString2, IsUUID, Matches as Matches2 } from "class-validator";
-function _ts_decorate8(decorators, target, key, desc) {
+function _ts_decorate12(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_decorate8, "_ts_decorate");
-function _ts_metadata6(k, v) {
+__name(_ts_decorate12, "_ts_decorate");
+function _ts_metadata10(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata6, "_ts_metadata");
+__name(_ts_metadata10, "_ts_metadata");
 var PLAN_OR_CYCLE_PATTERN2 = /^[A-Z][A-Z0-9_]*$/;
 var PROMO_CODE_PATTERN = /^[A-Z0-9_-]{4,32}$/i;
 var CompleteOnboardingSubscriptionDto = class {
@@ -1769,52 +3377,52 @@ var CompleteOnboardingSubscriptionDto = class {
    */
   bundleVersionIds;
 };
-_ts_decorate8([
+_ts_decorate12([
   IsString2(),
   Matches2(PLAN_OR_CYCLE_PATTERN2, {
     message: "plan must be SCREAMING_SNAKE_CASE"
   }),
-  _ts_metadata6("design:type", String)
+  _ts_metadata10("design:type", String)
 ], CompleteOnboardingSubscriptionDto.prototype, "plan", void 0);
-_ts_decorate8([
+_ts_decorate12([
   IsString2(),
   Matches2(PLAN_OR_CYCLE_PATTERN2, {
     message: "billingCycle must be SCREAMING_SNAKE_CASE (e.g. MONTHLY, YEARLY)"
   }),
-  _ts_metadata6("design:type", String)
+  _ts_metadata10("design:type", String)
 ], CompleteOnboardingSubscriptionDto.prototype, "billingCycle", void 0);
-_ts_decorate8([
+_ts_decorate12([
   IsOptional2(),
   IsString2(),
   Matches2(PROMO_CODE_PATTERN, {
     message: 'promoCode must consist of A\u2013Z, 0\u20139, "-", "_" (4\u201332 characters)'
   }),
-  _ts_metadata6("design:type", String)
+  _ts_metadata10("design:type", String)
 ], CompleteOnboardingSubscriptionDto.prototype, "promoCode", void 0);
-_ts_decorate8([
+_ts_decorate12([
   IsOptional2(),
   IsArray(),
   ArrayMaxSize(10),
   IsUUID("all", {
     each: true
   }),
-  _ts_metadata6("design:type", Array)
+  _ts_metadata10("design:type", Array)
 ], CompleteOnboardingSubscriptionDto.prototype, "bundleVersionIds", void 0);
 
 // src/billing/dto/subscription-bundles.dto.ts
 import { ArrayMaxSize as ArrayMaxSize2, IsArray as IsArray2, IsIn, IsInt, IsOptional as IsOptional3, IsUUID as IsUUID2, Matches as Matches3, Max, Min } from "class-validator";
 import { BUNDLE_PRICE_LOOKUP_LIMIT } from "@saasicat/core";
-function _ts_decorate9(decorators, target, key, desc) {
+function _ts_decorate13(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_decorate9, "_ts_decorate");
-function _ts_metadata7(k, v) {
+__name(_ts_decorate13, "_ts_decorate");
+function _ts_metadata11(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata7, "_ts_metadata");
+__name(_ts_metadata11, "_ts_metadata");
 var ISO_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}(T.*)?$/;
 var AddSubscriptionBundleDto = class {
   static {
@@ -1839,24 +3447,24 @@ var AddSubscriptionBundleDto = class {
    */
   billingCycle;
 };
-_ts_decorate9([
+_ts_decorate13([
   IsUUID2(),
-  _ts_metadata7("design:type", String)
+  _ts_metadata11("design:type", String)
 ], AddSubscriptionBundleDto.prototype, "bundleVersionId", void 0);
-_ts_decorate9([
+_ts_decorate13([
   IsOptional3(),
   IsInt(),
   Min(0),
   Max(120),
-  _ts_metadata7("design:type", Number)
+  _ts_metadata11("design:type", Number)
 ], AddSubscriptionBundleDto.prototype, "minimumTermMonths", void 0);
-_ts_decorate9([
+_ts_decorate13([
   IsOptional3(),
   IsIn([
     "MONTHLY",
     "YEARLY"
   ]),
-  _ts_metadata7("design:type", String)
+  _ts_metadata11("design:type", String)
 ], AddSubscriptionBundleDto.prototype, "billingCycle", void 0);
 var PreviewSubscriptionBundleDto = class {
   static {
@@ -1880,30 +3488,30 @@ var PreviewSubscriptionBundleDto = class {
    */
   billingCycle;
 };
-_ts_decorate9([
+_ts_decorate13([
   IsOptional3(),
   IsUUID2(),
-  _ts_metadata7("design:type", String)
+  _ts_metadata11("design:type", String)
 ], PreviewSubscriptionBundleDto.prototype, "bundleVersionId", void 0);
-_ts_decorate9([
+_ts_decorate13([
   IsOptional3(),
   IsUUID2(),
-  _ts_metadata7("design:type", String)
+  _ts_metadata11("design:type", String)
 ], PreviewSubscriptionBundleDto.prototype, "subscriptionBundleId", void 0);
-_ts_decorate9([
+_ts_decorate13([
   IsOptional3(),
   IsInt(),
   Min(0),
   Max(120),
-  _ts_metadata7("design:type", Number)
+  _ts_metadata11("design:type", Number)
 ], PreviewSubscriptionBundleDto.prototype, "minimumTermMonths", void 0);
-_ts_decorate9([
+_ts_decorate13([
   IsOptional3(),
   IsIn([
     "MONTHLY",
     "YEARLY"
   ]),
-  _ts_metadata7("design:type", String)
+  _ts_metadata11("design:type", String)
 ], PreviewSubscriptionBundleDto.prototype, "billingCycle", void 0);
 var CancelSubscriptionBundleDto = class {
   static {
@@ -1916,12 +3524,12 @@ var CancelSubscriptionBundleDto = class {
    */
   canceledAt;
 };
-_ts_decorate9([
+_ts_decorate13([
   IsOptional3(),
   Matches3(ISO_DATE_PATTERN, {
     message: "canceledAt must be an ISO date (YYYY-MM-DD)"
   }),
-  _ts_metadata7("design:type", String)
+  _ts_metadata11("design:type", String)
 ], CancelSubscriptionBundleDto.prototype, "canceledAt", void 0);
 var BundlePriceLookupDto = class {
   static {
@@ -1933,35 +3541,35 @@ var BundlePriceLookupDto = class {
    */
   bundleVersionIds;
 };
-_ts_decorate9([
+_ts_decorate13([
   IsArray2(),
   ArrayMaxSize2(BUNDLE_PRICE_LOOKUP_LIMIT),
   IsUUID2("4", {
     each: true
   }),
-  _ts_metadata7("design:type", Array)
+  _ts_metadata11("design:type", Array)
 ], BundlePriceLookupDto.prototype, "bundleVersionIds", void 0);
 
 // src/billing/subscription-bundles.service.ts
-import { Inject as Inject5, Injectable as Injectable5, NotFoundException as NotFoundException2, Optional as Optional5, UnprocessableEntityException as UnprocessableEntityException2 } from "@nestjs/common";
+import { Inject as Inject9, Injectable as Injectable8, NotFoundException as NotFoundException2, Optional as Optional7, UnprocessableEntityException as UnprocessableEntityException2 } from "@nestjs/common";
 import { BILLING_ERROR_CODES as BILLING_ERROR_CODES2, CATALOG_ERROR_CODES } from "@saasicat/core";
-function _ts_decorate10(decorators, target, key, desc) {
+function _ts_decorate14(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_decorate10, "_ts_decorate");
-function _ts_metadata8(k, v) {
+__name(_ts_decorate14, "_ts_decorate");
+function _ts_metadata12(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata8, "_ts_metadata");
-function _ts_param5(paramIndex, decorator) {
+__name(_ts_metadata12, "_ts_metadata");
+function _ts_param9(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param5, "_ts_param");
+__name(_ts_param9, "_ts_param");
 var SubscriptionBundlesService = class {
   static {
     __name(this, "SubscriptionBundlesService");
@@ -2202,16 +3810,16 @@ var SubscriptionBundlesService = class {
     return this.repo.reactivate(subscriptionBundleId);
   }
 };
-SubscriptionBundlesService = _ts_decorate10([
-  Injectable5(),
-  _ts_param5(0, Inject5(SUBSCRIPTION_BUNDLE_REPOSITORY_TOKEN)),
-  _ts_param5(1, Inject5(BUNDLE_REPOSITORY_TOKEN)),
-  _ts_param5(2, Optional5()),
-  _ts_param5(2, Inject5(SUBSCRIPTION_BUNDLE_CONFIG_TOKEN)),
-  _ts_param5(3, Optional5()),
-  _ts_param5(3, Inject5(SELF_SERVICE_BLOCKED_BUNDLES_TOKEN)),
-  _ts_metadata8("design:type", Function),
-  _ts_metadata8("design:paramtypes", [
+SubscriptionBundlesService = _ts_decorate14([
+  Injectable8(),
+  _ts_param9(0, Inject9(SUBSCRIPTION_BUNDLE_REPOSITORY_TOKEN)),
+  _ts_param9(1, Inject9(BUNDLE_REPOSITORY_TOKEN)),
+  _ts_param9(2, Optional7()),
+  _ts_param9(2, Inject9(SUBSCRIPTION_BUNDLE_CONFIG_TOKEN)),
+  _ts_param9(3, Optional7()),
+  _ts_param9(3, Inject9(SELF_SERVICE_BLOCKED_BUNDLES_TOKEN)),
+  _ts_metadata12("design:type", Function),
+  _ts_metadata12("design:paramtypes", [
     typeof SubscriptionBundleRepository === "undefined" ? Object : SubscriptionBundleRepository,
     typeof BundleRepository === "undefined" ? Object : BundleRepository,
     typeof SubscriptionBundleConfig === "undefined" ? Object : SubscriptionBundleConfig,
@@ -2243,25 +3851,38 @@ function clampToParent(ownTermEndsAt, parentEndsAt) {
 __name(clampToParent, "clampToParent");
 
 // src/billing/tenant-billing.controller.ts
-import { BadRequestException, Body, Controller as Controller2, ForbiddenException as ForbiddenException2, Get as Get2, HttpCode, HttpStatus, Inject as Inject6, Logger as Logger2, ConflictException, NotFoundException as NotFoundException3, Optional as Optional6, Post, Req, UseGuards } from "@nestjs/common";
+import { BadRequestException, Body, Controller as Controller3, ForbiddenException as ForbiddenException2, Get as Get3, HttpCode, HttpStatus, Inject as Inject10, Logger as Logger4, ConflictException, NotFoundException as NotFoundException3, Optional as Optional8, Post, Req, UseGuards as UseGuards2 } from "@nestjs/common";
 import { AUTH_ERROR_CODES as AUTH_ERROR_CODES2, BILLING_ERROR_CODES as BILLING_ERROR_CODES3 } from "@saasicat/core";
-function _ts_decorate11(decorators, target, key, desc) {
+
+// src/billing/charges/record-charges-after.ts
+async function recordChargesAfter(charges, tenantId, change, logger) {
+  if (!charges) return;
+  try {
+    await charges.recordDueCharges(tenantId);
+  } catch (err) {
+    logger.error(`Recording charges after ${change} failed (tenant ${tenantId}): ${String(err)}`);
+  }
+}
+__name(recordChargesAfter, "recordChargesAfter");
+
+// src/billing/tenant-billing.controller.ts
+function _ts_decorate15(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_decorate11, "_ts_decorate");
-function _ts_metadata9(k, v) {
+__name(_ts_decorate15, "_ts_decorate");
+function _ts_metadata13(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata9, "_ts_metadata");
-function _ts_param6(paramIndex, decorator) {
+__name(_ts_metadata13, "_ts_metadata");
+function _ts_param10(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param6, "_ts_param");
+__name(_ts_param10, "_ts_param");
 var TenantBillingController = class _TenantBillingController {
   static {
     __name(this, "TenantBillingController");
@@ -2282,7 +3903,8 @@ var TenantBillingController = class _TenantBillingController {
   contractFreeze;
   trialProjection;
   cancellationNoticeDays;
-  constructor(entitlements, planPreview, subscriptionUsage, usageSnapshot, subscriptionWrite, tenantIdResolver = null, userIdResolver = null, blockedPlans = null, promoCodes = null, auditService = null, userEmailResolver = null, auditContextResolver = null, subscriptionBundles = null, contractFreeze = null, trialProjection = null, cancellationNoticeDays = NO_NOTICE_PERIOD) {
+  charges;
+  constructor(entitlements, planPreview, subscriptionUsage, usageSnapshot, subscriptionWrite, tenantIdResolver = null, userIdResolver = null, blockedPlans = null, promoCodes = null, auditService = null, userEmailResolver = null, auditContextResolver = null, subscriptionBundles = null, contractFreeze = null, trialProjection = null, cancellationNoticeDays = NO_NOTICE_PERIOD, charges = null) {
     this.entitlements = entitlements;
     this.planPreview = planPreview;
     this.subscriptionUsage = subscriptionUsage;
@@ -2299,8 +3921,9 @@ var TenantBillingController = class _TenantBillingController {
     this.contractFreeze = contractFreeze;
     this.trialProjection = trialProjection;
     this.cancellationNoticeDays = cancellationNoticeDays;
+    this.charges = charges;
   }
-  logger = new Logger2(_TenantBillingController.name);
+  logger = new Logger4(_TenantBillingController.name);
   // ---------------------------------------------------------------------
   // Reads (Phase B) — all authenticated tenant users
   // ---------------------------------------------------------------------
@@ -2456,7 +4079,8 @@ var TenantBillingController = class _TenantBillingController {
     };
     if (decision.isImmediate) {
       const wasTrial = sub.status === "TRIAL";
-      const period = wasTrial || cancellationOutstanding ? null : initialPeriodWindow(/* @__PURE__ */ new Date(), dto.billingCycle);
+      const opensPeriod = decision.proration?.basis === "newPeriod";
+      const period = wasTrial || cancellationOutstanding || !opensPeriod ? null : initialPeriodWindow(/* @__PURE__ */ new Date(), dto.billingCycle);
       const trialEndsAt = wasTrial && this.trialProjection ? await this.trialProjection.projectTrialEndsAt({
         currentPlan: sub.plan,
         targetPlan: dto.plan,
@@ -2486,6 +4110,7 @@ var TenantBillingController = class _TenantBillingController {
         // contract it freezes still ends when the subscription does.
         sub.canceledEffectiveAt ?? sub.canceledAt ?? null
       );
+      await recordChargesAfter(this.charges, tenantId, "a plan change", this.logger);
       await this.auditLog(req, userId, "Subscription", tenantId, "CHANGE_PLAN", {
         fromPlan: sub.plan,
         fromCycle: sub.billingCycle,
@@ -2658,7 +4283,6 @@ var TenantBillingController = class _TenantBillingController {
         }
       }
     }
-    await this.tryFreezeOnPlanChange(tenantId, dto.plan, dto.billingCycle, wasTrial);
     this.entitlements.invalidateTenant(tenantId);
     await this.auditLog(req, userId, "Subscription", tenantId, "COMPLETE_ONBOARDING_SUBSCRIPTION", {
       plan: planResult.plan,
@@ -2698,6 +4322,8 @@ var TenantBillingController = class _TenantBillingController {
     } else if (bundleVersionIds.length > 0 && !this.subscriptionBundles) {
       warnings.push("Bundle bookings were requested during onboarding, but SubscriptionBundleModule is not registered in the consumer. No bundles were created.");
     }
+    await this.tryFreezeOnPlanChange(tenantId, dto.plan, dto.billingCycle, wasTrial);
+    await recordChargesAfter(this.charges, tenantId, "onboarding", this.logger);
     return {
       plan: planResult.plan,
       // The adapter returns `string`; the UI expects `'MONTHLY' | 'YEARLY'`.
@@ -2976,115 +4602,117 @@ var TenantBillingController = class _TenantBillingController {
     }
   }
 };
-_ts_decorate11([
-  Get2("entitlement"),
-  _ts_param6(0, Req()),
-  _ts_metadata9("design:type", Function),
-  _ts_metadata9("design:paramtypes", [
+_ts_decorate15([
+  Get3("entitlement"),
+  _ts_param10(0, Req()),
+  _ts_metadata13("design:type", Function),
+  _ts_metadata13("design:paramtypes", [
     typeof RequestLike === "undefined" ? Object : RequestLike
   ]),
-  _ts_metadata9("design:returntype", Promise)
+  _ts_metadata13("design:returntype", Promise)
 ], TenantBillingController.prototype, "getEntitlement", null);
-_ts_decorate11([
-  Get2("usage"),
-  _ts_param6(0, Req()),
-  _ts_metadata9("design:type", Function),
-  _ts_metadata9("design:paramtypes", [
+_ts_decorate15([
+  Get3("usage"),
+  _ts_param10(0, Req()),
+  _ts_metadata13("design:type", Function),
+  _ts_metadata13("design:paramtypes", [
     typeof RequestLike === "undefined" ? Object : RequestLike
   ]),
-  _ts_metadata9("design:returntype", Promise)
+  _ts_metadata13("design:returntype", Promise)
 ], TenantBillingController.prototype, "getUsage", null);
-_ts_decorate11([
+_ts_decorate15([
   Post("plan/preview"),
   HttpCode(HttpStatus.OK),
-  UseGuards(TenantAdminGuard),
-  _ts_param6(0, Req()),
-  _ts_param6(1, Body()),
-  _ts_metadata9("design:type", Function),
-  _ts_metadata9("design:paramtypes", [
+  UseGuards2(TenantAdminGuard),
+  _ts_param10(0, Req()),
+  _ts_param10(1, Body()),
+  _ts_metadata13("design:type", Function),
+  _ts_metadata13("design:paramtypes", [
     typeof RequestLike === "undefined" ? Object : RequestLike,
     typeof PreviewPlanChangeDto === "undefined" ? Object : PreviewPlanChangeDto
   ]),
-  _ts_metadata9("design:returntype", Promise)
+  _ts_metadata13("design:returntype", Promise)
 ], TenantBillingController.prototype, "previewPlanChange", null);
-_ts_decorate11([
+_ts_decorate15([
   Post("plan"),
-  UseGuards(TenantAdminGuard),
-  _ts_param6(0, Req()),
-  _ts_param6(1, Body()),
-  _ts_metadata9("design:type", Function),
-  _ts_metadata9("design:paramtypes", [
+  UseGuards2(TenantAdminGuard),
+  _ts_param10(0, Req()),
+  _ts_param10(1, Body()),
+  _ts_metadata13("design:type", Function),
+  _ts_metadata13("design:paramtypes", [
     typeof RequestLike === "undefined" ? Object : RequestLike,
     typeof ChangePlanDto === "undefined" ? Object : ChangePlanDto
   ]),
-  _ts_metadata9("design:returntype", Promise)
+  _ts_metadata13("design:returntype", Promise)
 ], TenantBillingController.prototype, "changePlan", null);
-_ts_decorate11([
+_ts_decorate15([
   Post("onboarding/initial-subscription"),
-  UseGuards(TenantAdminGuard),
-  _ts_param6(0, Req()),
-  _ts_param6(1, Body()),
-  _ts_metadata9("design:type", Function),
-  _ts_metadata9("design:paramtypes", [
+  UseGuards2(TenantAdminGuard),
+  _ts_param10(0, Req()),
+  _ts_param10(1, Body()),
+  _ts_metadata13("design:type", Function),
+  _ts_metadata13("design:paramtypes", [
     typeof RequestLike === "undefined" ? Object : RequestLike,
     typeof CompleteOnboardingSubscriptionDto === "undefined" ? Object : CompleteOnboardingSubscriptionDto
   ]),
-  _ts_metadata9("design:returntype", Promise)
+  _ts_metadata13("design:returntype", Promise)
 ], TenantBillingController.prototype, "completeOnboardingSubscription", null);
-_ts_decorate11([
+_ts_decorate15([
   Post("subscription/accept-pending-version"),
-  UseGuards(TenantAdminGuard),
-  _ts_param6(0, Req()),
-  _ts_metadata9("design:type", Function),
-  _ts_metadata9("design:paramtypes", [
+  UseGuards2(TenantAdminGuard),
+  _ts_param10(0, Req()),
+  _ts_metadata13("design:type", Function),
+  _ts_metadata13("design:paramtypes", [
     typeof RequestLike === "undefined" ? Object : RequestLike
   ]),
-  _ts_metadata9("design:returntype", Promise)
+  _ts_metadata13("design:returntype", Promise)
 ], TenantBillingController.prototype, "acceptPendingPlanVersion", null);
-_ts_decorate11([
+_ts_decorate15([
   Post("cancel"),
-  UseGuards(TenantAdminGuard),
-  _ts_param6(0, Req()),
-  _ts_param6(1, Body()),
-  _ts_metadata9("design:type", Function),
-  _ts_metadata9("design:paramtypes", [
+  UseGuards2(TenantAdminGuard),
+  _ts_param10(0, Req()),
+  _ts_param10(1, Body()),
+  _ts_metadata13("design:type", Function),
+  _ts_metadata13("design:paramtypes", [
     typeof RequestLike === "undefined" ? Object : RequestLike,
     typeof CancelSubscriptionDto === "undefined" ? Object : CancelSubscriptionDto
   ]),
-  _ts_metadata9("design:returntype", Promise)
+  _ts_metadata13("design:returntype", Promise)
 ], TenantBillingController.prototype, "cancelSubscription", null);
-TenantBillingController = _ts_decorate11([
-  Controller2("billing"),
-  UseGuards(ComposedTenantAuthGuard),
-  _ts_param6(0, Inject6(ENTITLEMENT_SERVICE_TOKEN)),
-  _ts_param6(1, Inject6(PlanChangePreviewService)),
-  _ts_param6(2, Inject6(SUBSCRIPTION_USAGE_PORT_TOKEN)),
-  _ts_param6(3, Inject6(USAGE_SNAPSHOT_PORT_TOKEN)),
-  _ts_param6(4, Inject6(SUBSCRIPTION_WRITE_PORT_TOKEN)),
-  _ts_param6(5, Optional6()),
-  _ts_param6(5, Inject6(TENANT_ID_RESOLVER_TOKEN)),
-  _ts_param6(6, Optional6()),
-  _ts_param6(6, Inject6(USER_ID_RESOLVER_TOKEN)),
-  _ts_param6(7, Optional6()),
-  _ts_param6(7, Inject6(SELF_SERVICE_BLOCKED_PLANS_TOKEN)),
-  _ts_param6(8, Optional6()),
-  _ts_param6(8, Inject6(PromoCodesService)),
-  _ts_param6(9, Optional6()),
-  _ts_param6(9, Inject6(AdminAuditService)),
-  _ts_param6(10, Optional6()),
-  _ts_param6(10, Inject6(USER_EMAIL_RESOLVER_TOKEN)),
-  _ts_param6(11, Optional6()),
-  _ts_param6(11, Inject6(AUDIT_CONTEXT_RESOLVER_TOKEN)),
-  _ts_param6(12, Optional6()),
-  _ts_param6(12, Inject6(SubscriptionBundlesService)),
-  _ts_param6(13, Optional6()),
-  _ts_param6(13, Inject6(CONTRACT_FREEZE_PORT_TOKEN)),
-  _ts_param6(14, Optional6()),
-  _ts_param6(14, Inject6(TRIAL_PROJECTION_PORT_TOKEN)),
-  _ts_param6(15, Optional6()),
-  _ts_param6(15, Inject6(CANCELLATION_NOTICE_DAYS_TOKEN)),
-  _ts_metadata9("design:type", Function),
-  _ts_metadata9("design:paramtypes", [
+TenantBillingController = _ts_decorate15([
+  Controller3("billing"),
+  UseGuards2(ComposedTenantAuthGuard),
+  _ts_param10(0, Inject10(ENTITLEMENT_SERVICE_TOKEN)),
+  _ts_param10(1, Inject10(PlanChangePreviewService)),
+  _ts_param10(2, Inject10(SUBSCRIPTION_USAGE_PORT_TOKEN)),
+  _ts_param10(3, Inject10(USAGE_SNAPSHOT_PORT_TOKEN)),
+  _ts_param10(4, Inject10(SUBSCRIPTION_WRITE_PORT_TOKEN)),
+  _ts_param10(5, Optional8()),
+  _ts_param10(5, Inject10(TENANT_ID_RESOLVER_TOKEN)),
+  _ts_param10(6, Optional8()),
+  _ts_param10(6, Inject10(USER_ID_RESOLVER_TOKEN)),
+  _ts_param10(7, Optional8()),
+  _ts_param10(7, Inject10(SELF_SERVICE_BLOCKED_PLANS_TOKEN)),
+  _ts_param10(8, Optional8()),
+  _ts_param10(8, Inject10(PromoCodesService)),
+  _ts_param10(9, Optional8()),
+  _ts_param10(9, Inject10(AdminAuditService)),
+  _ts_param10(10, Optional8()),
+  _ts_param10(10, Inject10(USER_EMAIL_RESOLVER_TOKEN)),
+  _ts_param10(11, Optional8()),
+  _ts_param10(11, Inject10(AUDIT_CONTEXT_RESOLVER_TOKEN)),
+  _ts_param10(12, Optional8()),
+  _ts_param10(12, Inject10(SubscriptionBundlesService)),
+  _ts_param10(13, Optional8()),
+  _ts_param10(13, Inject10(CONTRACT_FREEZE_PORT_TOKEN)),
+  _ts_param10(14, Optional8()),
+  _ts_param10(14, Inject10(TRIAL_PROJECTION_PORT_TOKEN)),
+  _ts_param10(15, Optional8()),
+  _ts_param10(15, Inject10(CANCELLATION_NOTICE_DAYS_TOKEN)),
+  _ts_param10(16, Optional8()),
+  _ts_param10(16, Inject10(SubscriberChargeService)),
+  _ts_metadata13("design:type", Function),
+  _ts_metadata13("design:paramtypes", [
     typeof EntitlementService === "undefined" ? Object : EntitlementService,
     typeof PlanChangePreviewService === "undefined" ? Object : PlanChangePreviewService,
     typeof SubscriptionUsagePort === "undefined" ? Object : SubscriptionUsagePort,
@@ -3100,20 +4728,21 @@ TenantBillingController = _ts_decorate11([
     Object,
     Object,
     Object,
-    typeof CancellationNoticePeriods === "undefined" ? Object : CancellationNoticePeriods
+    typeof CancellationNoticePeriods === "undefined" ? Object : CancellationNoticePeriods,
+    Object
   ])
 ], TenantBillingController);
 
 // src/billing/tenant-billing.module.ts
-import { Module as Module2 } from "@nestjs/common";
+import { Module as Module3 } from "@nestjs/common";
 import { planCatalogSchema as planCatalogSchema2 } from "@saasicat/spec";
-function _ts_decorate12(decorators, target, key, desc) {
+function _ts_decorate16(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_decorate12, "_ts_decorate");
+__name(_ts_decorate16, "_ts_decorate");
 function settingFromCatalog(catalog, key) {
   const settings = catalog.tenantBilling;
   const value = settings?.[key];
@@ -3178,10 +4807,20 @@ var TenantBillingModule = class _TenantBillingModule {
       if (!options.contractFreeze.subscriberRepository) {
         throw new Error("TenantBillingModule: `contractFreeze` needs `subscriberRepository` \u2014 a frozen contract names the subscriber it is concluded with, and a plan change for a tenant without one is refused before anything changes.");
       }
-      providers.push(asProvider(CONTRACT_FREEZE_SOURCE_PORT_TOKEN, options.contractFreeze.sourcePort), asProvider(SUBSCRIPTION_CONTRACT_REPOSITORY_TOKEN, options.contractFreeze.subscriptionContractRepository), ...subscriberProviders(options.contractFreeze.subscriberRepository), SubscriptionContractService, {
+      providers.push(asProvider(CONTRACT_FREEZE_SOURCE_PORT_TOKEN, options.contractFreeze.sourcePort), asProvider(SUBSCRIPTION_CONTRACT_REPOSITORY_TOKEN, options.contractFreeze.subscriptionContractRepository), ...subscriberProviders(options.contractFreeze.subscriberRepository), SubscriptionContractService, SubscriptionContractFreezeService, {
         provide: CONTRACT_FREEZE_PORT_TOKEN,
-        useClass: SubscriptionContractFreezeService
-      });
+        useExisting: SubscriptionContractFreezeService
+      }, ContractRefreshService);
+      if (options.contractFreeze.transactionRunner) {
+        providers.push(asProvider(CONTRACT_TRANSACTION_RUNNER_TOKEN, options.contractFreeze.transactionRunner));
+      }
+    }
+    const hasChargeJournal = Boolean(options.chargeJournal);
+    if (options.chargeJournal) {
+      if (!options.contractFreeze) {
+        throw new Error("TenantBillingModule: `chargeJournal` needs `contractFreeze` \u2014 a charge points at a line of a frozen contract, and the contracts and the subscribers they are concluded with come from there.");
+      }
+      providers.push(asProvider(SUBSCRIBER_LEDGER_REPOSITORY_TOKEN, options.chargeJournal.ledgerRepository), SubscriberChargeService, SubscriberAccountService);
     }
     if (options.tenantIdResolver) {
       providers.push({
@@ -3227,37 +4866,42 @@ var TenantBillingModule = class _TenantBillingModule {
           PendingPlanMaterializationService
         ] : [],
         ...hasContractFreeze ? [
-          CONTRACT_FREEZE_PORT_TOKEN
+          CONTRACT_FREEZE_PORT_TOKEN,
+          ContractRefreshService
+        ] : [],
+        ...hasChargeJournal ? [
+          SubscriberChargeService,
+          SubscriberAccountService
         ] : [],
         ...options.extraExports ?? []
       ]
     };
   }
 };
-TenantBillingModule = _ts_decorate12([
-  Module2({})
+TenantBillingModule = _ts_decorate16([
+  Module3({})
 ], TenantBillingModule);
 
 // src/billing/subscription-bundle-preview.service.ts
-import { Inject as Inject7, Injectable as Injectable6, NotFoundException as NotFoundException4, Optional as Optional7 } from "@nestjs/common";
+import { Inject as Inject11, Injectable as Injectable9, NotFoundException as NotFoundException4, Optional as Optional9 } from "@nestjs/common";
 import { BILLING_ERROR_CODES as BILLING_ERROR_CODES4, CATALOG_ERROR_CODES as CATALOG_ERROR_CODES2, buildFeatureRequiresIndex as buildFeatureRequiresIndex2, collectUnsatisfiedRequires as collectUnsatisfiedRequires2 } from "@saasicat/core";
-function _ts_decorate13(decorators, target, key, desc) {
+function _ts_decorate17(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_decorate13, "_ts_decorate");
-function _ts_metadata10(k, v) {
+__name(_ts_decorate17, "_ts_decorate");
+function _ts_metadata14(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata10, "_ts_metadata");
-function _ts_param7(paramIndex, decorator) {
+__name(_ts_metadata14, "_ts_metadata");
+function _ts_param11(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param7, "_ts_param");
+__name(_ts_param11, "_ts_param");
 var SubscriptionBundlePreviewService = class {
   static {
     __name(this, "SubscriptionBundlePreviewService");
@@ -3527,20 +5171,20 @@ var SubscriptionBundlePreviewService = class {
     return collectUnsatisfiedRequires2(bundleVersion.features ?? [], requiresIndex).filter((key) => !covered.has(key));
   }
 };
-SubscriptionBundlePreviewService = _ts_decorate13([
-  Injectable6(),
-  _ts_param7(0, Inject7(SUBSCRIPTION_BUNDLE_REPOSITORY_TOKEN)),
-  _ts_param7(1, Inject7(BUNDLE_REPOSITORY_TOKEN)),
-  _ts_param7(2, Optional7()),
-  _ts_param7(2, Inject7(PLAN_REPOSITORY_TOKEN)),
-  _ts_param7(3, Optional7()),
-  _ts_param7(3, Inject7(CATALOG_ENTRY_REPOSITORY_TOKEN)),
-  _ts_param7(4, Optional7()),
-  _ts_param7(4, Inject7(SELF_SERVICE_BLOCKED_BUNDLES_TOKEN)),
-  _ts_param7(5, Optional7()),
-  _ts_param7(5, Inject7(SUBSCRIPTION_BUNDLE_CONFIG_TOKEN)),
-  _ts_metadata10("design:type", Function),
-  _ts_metadata10("design:paramtypes", [
+SubscriptionBundlePreviewService = _ts_decorate17([
+  Injectable9(),
+  _ts_param11(0, Inject11(SUBSCRIPTION_BUNDLE_REPOSITORY_TOKEN)),
+  _ts_param11(1, Inject11(BUNDLE_REPOSITORY_TOKEN)),
+  _ts_param11(2, Optional9()),
+  _ts_param11(2, Inject11(PLAN_REPOSITORY_TOKEN)),
+  _ts_param11(3, Optional9()),
+  _ts_param11(3, Inject11(CATALOG_ENTRY_REPOSITORY_TOKEN)),
+  _ts_param11(4, Optional9()),
+  _ts_param11(4, Inject11(SELF_SERVICE_BLOCKED_BUNDLES_TOKEN)),
+  _ts_param11(5, Optional9()),
+  _ts_param11(5, Inject11(SUBSCRIPTION_BUNDLE_CONFIG_TOKEN)),
+  _ts_metadata14("design:type", Function),
+  _ts_metadata14("design:paramtypes", [
     typeof SubscriptionBundleRepository === "undefined" ? Object : SubscriptionBundleRepository,
     typeof BundleRepository === "undefined" ? Object : BundleRepository,
     Object,
@@ -3565,25 +5209,29 @@ function toSnapshot(bundleVersion) {
 __name(toSnapshot, "toSnapshot");
 
 // src/billing/tenant-subscription-bundles.controller.ts
-import { BadRequestException as BadRequestException2, Body as Body2, Controller as Controller3, Delete, Get as Get3, HttpCode as HttpCode2, HttpStatus as HttpStatus2, Inject as Inject8, Logger as Logger3, ConflictException as ConflictException2, NotFoundException as NotFoundException5, Optional as Optional8, Param, ParseUUIDPipe, Post as Post2, Req as Req2, UseGuards as UseGuards2 } from "@nestjs/common";
+import { BadRequestException as BadRequestException2, Body as Body2, Controller as Controller4, Delete, Get as Get4, HttpCode as HttpCode2, HttpStatus as HttpStatus2, Inject as Inject12, Logger as Logger5, ConflictException as ConflictException2, NotFoundException as NotFoundException5, Optional as Optional10, Param as Param2, ParseUUIDPipe, Post as Post2, Req as Req2, UseGuards as UseGuards3 } from "@nestjs/common";
 import { AUTH_ERROR_CODES as AUTH_ERROR_CODES3, BILLING_ERROR_CODES as BILLING_ERROR_CODES5 } from "@saasicat/core";
-function _ts_decorate14(decorators, target, key, desc) {
+function _ts_decorate18(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_decorate14, "_ts_decorate");
-function _ts_metadata11(k, v) {
+__name(_ts_decorate18, "_ts_decorate");
+function _ts_metadata15(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata11, "_ts_metadata");
-function _ts_param8(paramIndex, decorator) {
+__name(_ts_metadata15, "_ts_metadata");
+function _ts_param12(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param8, "_ts_param");
+__name(_ts_param12, "_ts_param");
+function planCycleOf2(sub) {
+  return sub.billingCycle;
+}
+__name(planCycleOf2, "planCycleOf");
 function buildTenantSubscriptionBundlesController(extraGuards = []) {
   let GeneratedTenantSubscriptionBundlesController = class GeneratedTenantSubscriptionBundlesController2 {
     static {
@@ -3594,19 +5242,21 @@ function buildTenantSubscriptionBundlesController(extraGuards = []) {
     subscriptionUsage;
     tenantIdResolver;
     contractFreeze;
-    logger = new Logger3("TenantSubscriptionBundlesController");
+    charges;
+    logger = new Logger5("TenantSubscriptionBundlesController");
     /** Keeps the "no contractFreeze hook" warning to one line per process. */
     static warnedAboutMissingFreeze = false;
-    constructor(service, previewService, subscriptionUsage, tenantIdResolver, contractFreeze = null) {
+    constructor(service, previewService, subscriptionUsage, tenantIdResolver, contractFreeze = null, charges = null) {
       this.service = service;
       this.previewService = previewService;
       this.subscriptionUsage = subscriptionUsage;
       this.tenantIdResolver = tenantIdResolver;
       this.contractFreeze = contractFreeze;
+      this.charges = charges;
     }
     async list(req) {
       const sub = await this.requireSubscription(this.requireTenantId(req));
-      return this.service.listForSubscription(this.requireSubscriptionPk(sub), sub.plan, sub.billingCycle);
+      return this.service.listForSubscription(this.requireSubscriptionPk(sub), sub.plan, planCycleOf2(sub));
     }
     /**
      * List prices for the bundles the store is showing, resolved for this
@@ -3636,7 +5286,7 @@ function buildTenantSubscriptionBundlesController(extraGuards = []) {
         // A bundle cannot commit past the subscription paying for it.
         parentEndsAt: sub.canceledEffectiveAt ?? sub.canceledAt ?? null,
         // And it runs in the plan's rhythm, on the plan's day.
-        planCycle: sub.billingCycle,
+        planCycle: planCycleOf2(sub),
         planPeriodEnd: sub.currentPeriodEnd ?? null,
         // Resolved rather than passed through: a null here would let
         // the arithmetic read the period END, which a short month has
@@ -3646,6 +5296,7 @@ function buildTenantSubscriptionBundlesController(extraGuards = []) {
         billingCycle: dto.billingCycle
       });
       await this.refreezeContract(tenantId, sub);
+      await recordChargesAfter(this.charges, tenantId, "an add-on booking", this.logger);
       return result;
     }
     async preview(req, dto) {
@@ -3662,7 +5313,7 @@ function buildTenantSubscriptionBundlesController(extraGuards = []) {
         subscriptionId: this.requireSubscriptionPk(sub),
         // Plan KEY (compatibility.planIds is key-based) — not the planVersion UUID.
         currentPlanKey: sub.plan,
-        billingCycle: sub.billingCycle,
+        billingCycle: planCycleOf2(sub),
         status: sub.status,
         startedAt: sub.startedAt,
         currentPeriodStart: sub.currentPeriodStart,
@@ -3772,7 +5423,7 @@ function buildTenantSubscriptionBundlesController(extraGuards = []) {
         await this.contractFreeze.freezeOnPlanChange(
           tenantId,
           sub.planVersion.planId,
-          sub.billingCycle,
+          planCycleOf2(sub),
           /* @__PURE__ */ new Date(),
           // Cancelling a bundle stays open on a cancelled
           // subscription, and it re-freezes: the replacement contract
@@ -3784,93 +5435,96 @@ function buildTenantSubscriptionBundlesController(extraGuards = []) {
       }
     }
   };
-  _ts_decorate14([
-    Get3(),
-    _ts_param8(0, Req2()),
-    _ts_metadata11("design:type", Function),
-    _ts_metadata11("design:paramtypes", [
+  _ts_decorate18([
+    Get4(),
+    _ts_param12(0, Req2()),
+    _ts_metadata15("design:type", Function),
+    _ts_metadata15("design:paramtypes", [
       typeof RequestLike === "undefined" ? Object : RequestLike
     ]),
-    _ts_metadata11("design:returntype", Promise)
+    _ts_metadata15("design:returntype", Promise)
   ], GeneratedTenantSubscriptionBundlesController.prototype, "list", null);
-  _ts_decorate14([
+  _ts_decorate18([
     Post2("prices"),
-    _ts_param8(0, Req2()),
-    _ts_param8(1, Body2()),
-    _ts_metadata11("design:type", Function),
-    _ts_metadata11("design:paramtypes", [
+    _ts_param12(0, Req2()),
+    _ts_param12(1, Body2()),
+    _ts_metadata15("design:type", Function),
+    _ts_metadata15("design:paramtypes", [
       typeof RequestLike === "undefined" ? Object : RequestLike,
       typeof BundlePriceLookupDto === "undefined" ? Object : BundlePriceLookupDto
     ]),
-    _ts_metadata11("design:returntype", Promise)
+    _ts_metadata15("design:returntype", Promise)
   ], GeneratedTenantSubscriptionBundlesController.prototype, "prices", null);
-  _ts_decorate14([
+  _ts_decorate18([
     Post2(),
-    UseGuards2(TenantAdminGuard),
-    _ts_param8(0, Req2()),
-    _ts_param8(1, Body2()),
-    _ts_metadata11("design:type", Function),
-    _ts_metadata11("design:paramtypes", [
+    UseGuards3(TenantAdminGuard),
+    _ts_param12(0, Req2()),
+    _ts_param12(1, Body2()),
+    _ts_metadata15("design:type", Function),
+    _ts_metadata15("design:paramtypes", [
       typeof RequestLike === "undefined" ? Object : RequestLike,
       typeof AddSubscriptionBundleDto === "undefined" ? Object : AddSubscriptionBundleDto
     ]),
-    _ts_metadata11("design:returntype", Promise)
+    _ts_metadata15("design:returntype", Promise)
   ], GeneratedTenantSubscriptionBundlesController.prototype, "add", null);
-  _ts_decorate14([
+  _ts_decorate18([
     Post2("preview"),
     HttpCode2(HttpStatus2.OK),
-    _ts_param8(0, Req2()),
-    _ts_param8(1, Body2()),
-    _ts_metadata11("design:type", Function),
-    _ts_metadata11("design:paramtypes", [
+    _ts_param12(0, Req2()),
+    _ts_param12(1, Body2()),
+    _ts_metadata15("design:type", Function),
+    _ts_metadata15("design:paramtypes", [
       typeof RequestLike === "undefined" ? Object : RequestLike,
       typeof PreviewSubscriptionBundleDto === "undefined" ? Object : PreviewSubscriptionBundleDto
     ]),
-    _ts_metadata11("design:returntype", Promise)
+    _ts_metadata15("design:returntype", Promise)
   ], GeneratedTenantSubscriptionBundlesController.prototype, "preview", null);
-  _ts_decorate14([
+  _ts_decorate18([
     Delete(":id"),
-    UseGuards2(TenantAdminGuard),
+    UseGuards3(TenantAdminGuard),
     HttpCode2(HttpStatus2.OK),
-    _ts_param8(0, Req2()),
-    _ts_param8(1, Param("id", new ParseUUIDPipe())),
-    _ts_param8(2, Body2()),
-    _ts_metadata11("design:type", Function),
-    _ts_metadata11("design:paramtypes", [
+    _ts_param12(0, Req2()),
+    _ts_param12(1, Param2("id", new ParseUUIDPipe())),
+    _ts_param12(2, Body2()),
+    _ts_metadata15("design:type", Function),
+    _ts_metadata15("design:paramtypes", [
       typeof RequestLike === "undefined" ? Object : RequestLike,
       String,
       typeof CancelSubscriptionBundleDto === "undefined" ? Object : CancelSubscriptionBundleDto
     ]),
-    _ts_metadata11("design:returntype", Promise)
+    _ts_metadata15("design:returntype", Promise)
   ], GeneratedTenantSubscriptionBundlesController.prototype, "cancel", null);
-  _ts_decorate14([
+  _ts_decorate18([
     Post2(":id/reactivate"),
-    UseGuards2(TenantAdminGuard),
+    UseGuards3(TenantAdminGuard),
     HttpCode2(HttpStatus2.OK),
-    _ts_param8(0, Req2()),
-    _ts_param8(1, Param("id", new ParseUUIDPipe())),
-    _ts_metadata11("design:type", Function),
-    _ts_metadata11("design:paramtypes", [
+    _ts_param12(0, Req2()),
+    _ts_param12(1, Param2("id", new ParseUUIDPipe())),
+    _ts_metadata15("design:type", Function),
+    _ts_metadata15("design:paramtypes", [
       typeof RequestLike === "undefined" ? Object : RequestLike,
       String
     ]),
-    _ts_metadata11("design:returntype", Promise)
+    _ts_metadata15("design:returntype", Promise)
   ], GeneratedTenantSubscriptionBundlesController.prototype, "reactivate", null);
-  GeneratedTenantSubscriptionBundlesController = _ts_decorate14([
-    Controller3("billing/subscription-bundles"),
-    UseGuards2(ComposedTenantAuthGuard, ...extraGuards),
-    _ts_param8(0, Inject8(SubscriptionBundlesService)),
-    _ts_param8(1, Inject8(SubscriptionBundlePreviewService)),
-    _ts_param8(2, Inject8(SUBSCRIPTION_USAGE_PORT_TOKEN)),
-    _ts_param8(3, Inject8(TENANT_ID_RESOLVER_TOKEN)),
-    _ts_param8(4, Optional8()),
-    _ts_param8(4, Inject8(CONTRACT_FREEZE_PORT_TOKEN)),
-    _ts_metadata11("design:type", Function),
-    _ts_metadata11("design:paramtypes", [
+  GeneratedTenantSubscriptionBundlesController = _ts_decorate18([
+    Controller4("billing/subscription-bundles"),
+    UseGuards3(ComposedTenantAuthGuard, ...extraGuards),
+    _ts_param12(0, Inject12(SubscriptionBundlesService)),
+    _ts_param12(1, Inject12(SubscriptionBundlePreviewService)),
+    _ts_param12(2, Inject12(SUBSCRIPTION_USAGE_PORT_TOKEN)),
+    _ts_param12(3, Inject12(TENANT_ID_RESOLVER_TOKEN)),
+    _ts_param12(4, Optional10()),
+    _ts_param12(4, Inject12(CONTRACT_FREEZE_PORT_TOKEN)),
+    _ts_param12(5, Optional10()),
+    _ts_param12(5, Inject12(SubscriberChargeService)),
+    _ts_metadata15("design:type", Function),
+    _ts_metadata15("design:paramtypes", [
       typeof SubscriptionBundlesService === "undefined" ? Object : SubscriptionBundlesService,
       typeof SubscriptionBundlePreviewService === "undefined" ? Object : SubscriptionBundlePreviewService,
       typeof SubscriptionUsagePort === "undefined" ? Object : SubscriptionUsagePort,
       typeof TenantIdResolver === "undefined" ? Object : TenantIdResolver,
+      Object,
       Object
     ])
   ], GeneratedTenantSubscriptionBundlesController);
@@ -3879,14 +5533,14 @@ function buildTenantSubscriptionBundlesController(extraGuards = []) {
 __name(buildTenantSubscriptionBundlesController, "buildTenantSubscriptionBundlesController");
 
 // src/billing/subscription-bundles.module.ts
-import { Module as Module3 } from "@nestjs/common";
-function _ts_decorate15(decorators, target, key, desc) {
+import { Module as Module4 } from "@nestjs/common";
+function _ts_decorate19(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_decorate15, "_ts_decorate");
+__name(_ts_decorate19, "_ts_decorate");
 var SubscriptionBundleModule = class _SubscriptionBundleModule {
   static {
     __name(this, "SubscriptionBundleModule");
@@ -3948,8 +5602,8 @@ var SubscriptionBundleModule = class _SubscriptionBundleModule {
     };
   }
 };
-SubscriptionBundleModule = _ts_decorate15([
-  Module3({})
+SubscriptionBundleModule = _ts_decorate19([
+  Module4({})
 ], SubscriptionBundleModule);
 
 export {
@@ -3989,11 +5643,22 @@ export {
   SELF_SERVICE_BLOCKED_PLANS_TOKEN,
   SELF_SERVICE_BLOCKED_BUNDLES_TOKEN,
   computeProration,
+  computeNewPeriodCharge,
   PlanChangePreviewService,
   CONTRACT_FREEZE_PORT_TOKEN,
   CONTRACT_FREEZE_SOURCE_PORT_TOKEN,
   PendingPlanMaterializationService,
   SubscriptionContractFreezeService,
+  featureChangeOf,
+  quotaChangesOf,
+  moneyChangesOf,
+  withAgreedTerms,
+  vocabularyOf,
+  ContractRefreshService,
+  SUBSCRIBER_LEDGER_REPOSITORY_TOKEN,
+  SubscriberAccountService,
+  SubscriberAccountModule,
+  SubscriberChargeService,
   PreviewPlanChangeDto,
   ChangePlanDto,
   CancelSubscriptionDto,