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

package/dist/{chunk-M47BNEY2.js → chunk-3YYLOYUT.js}

@@ -1,12 +1,18 @@
+import {
+  AdminResourcesService
+} from "./chunk-OSOP4KWL.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";
+  SubscriptionContractService,
+  generatedDiscountLine
+} from "./chunk-EU4N5LET.js";
 import {
   resolveBundlePriceNet
 } from "./chunk-KPEMTBOP.js";
@@ -16,7 +22,7 @@ import {
   SUBSCRIPTION_BUNDLE_REPOSITORY_TOKEN,
   cancellationHasLanded,
   toEffectiveLimitsSnapshot
-} from "./chunk-G6EZWECL.js";
+} from "./chunk-B4YP7REK.js";
 import {
   ENTITLEMENT_SERVICE_TOKEN
 } from "./chunk-OUDSQ3PU.js";
@@ -61,9 +67,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 +1040,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 +1122,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 +1131,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 +1216,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 +1403,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 +1451,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 +1461,7 @@ PlanChangePreviewService = _ts_decorate4([
     typeof UsageSnapshotPort === "undefined" ? Object : UsageSnapshotPort,
     Object,
     Object,
+    Object,
     Object
   ])
 ], PlanChangePreviewService);
@@ -1536,11 +1606,15 @@ var SubscriptionContractFreezeService = class {
   entitlements;
   contracts;
   source;
-  constructor(catalogs, entitlements, contracts, source, writes = null) {
+  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`.");
     }
@@ -1598,9 +1672,13 @@ var SubscriptionContractFreezeService = class {
       quotaEffectsSnapshot: planDef.quotas,
       metadata: null
     };
+    const redeemed = await this.redeemedCodeNotYetRecorded(tenantId, planPriceNet, billingCycle, vatRate);
     const lineItems = recordContractLinesMoney([
       planLineItem,
-      ...bundles.lineItems
+      ...bundles.lineItems,
+      ...redeemed ? [
+        redeemed.line
+      ] : []
     ], {
       currency: catalog.currency,
       taxRate: vatRate
@@ -1627,7 +1705,7 @@ var SubscriptionContractFreezeService = class {
       });
     }
     this.entitlements.invalidateTenant(tenantId);
-    const limits = await this.entitlements.computeLimits(tenantId, effectiveFrom, catalog);
+    const { limits, leftOutBundleVersionIds } = await this.entitlements.computeContractLimits(tenantId, effectiveFrom, catalog);
     const data = {
       tenantId,
       status: "active",
@@ -1646,14 +1724,81 @@ var SubscriptionContractFreezeService = class {
         },
         features: [
           ...limits.features
-        ]
+        ],
+        ...leftOutBundleVersionIds.length > 0 ? {
+          leftOutBundleVersionIds
+        } : {}
       },
       priceSnapshot,
+      promoCodeSnapshots: redeemed ? [
+        redeemed.snapshot
+      ] : [],
       lineItems
     };
     await this.contracts.create(data);
     this.entitlements.invalidateTenant(tenantId);
   }
+  /**
+   * 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(),
@@ -1663,18 +1808,76 @@ SubscriptionContractFreezeService = _ts_decorate6([
   _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/dto/tenant-billing.dto.ts
-import { IsISO8601, IsOptional, IsString, Matches } from "class-validator";
+// 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 Inject5, Injectable as Injectable5 } 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_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);
@@ -1686,6 +1889,863 @@ 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 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_decorate7([
+  Injectable5(),
+  _ts_param5(0, Inject5(SUBSCRIBER_LEDGER_REPOSITORY_TOKEN)),
+  _ts_param5(1, Inject5(SUBSCRIPTION_CONTRACT_REPOSITORY_TOKEN)),
+  _ts_param5(2, Inject5(SUBSCRIBER_REPOSITORY_TOKEN)),
+  _ts_param5(3, Inject5(SUBSCRIPTION_USAGE_PORT_TOKEN)),
+  _ts_metadata5("design:type", Function),
+  _ts_metadata5("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 Inject6, Module as Module2, Param, UseGuards } from "@nestjs/common";
+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");
+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_decorate8([
+    Get2("tenants/:slug/charges"),
+    _ts_param6(0, Param("slug")),
+    _ts_metadata6("design:type", Function),
+    _ts_metadata6("design:paramtypes", [
+      String
+    ]),
+    _ts_metadata6("design:returntype", typeof Promise === "undefined" ? Object : Promise)
+  ], GeneratedSubscriberAccountController.prototype, "chargesOf", null);
+  GeneratedSubscriberAccountController = _ts_decorate8([
+    Controller2("admin"),
+    UseGuards(...guards),
+    _ts_param6(0, Inject6(AdminResourcesService)),
+    _ts_param6(1, Inject6(SubscriberAccountService)),
+    _ts_param6(2, Inject6(RLS_BYPASS_PORT_TOKEN)),
+    _ts_metadata6("design:type", Function),
+    _ts_metadata6("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_decorate8([
+  Module2({})
+], SubscriberAccountModule);
+
+// src/billing/charges/subscriber-charge.service.ts
+import { Inject as Inject7, Injectable as Injectable6, Logger as Logger2, Optional as Optional5 } 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_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 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, "SubscriberChargeService");
+  }
+  ledger;
+  contracts;
+  subscribers;
+  subscriptions;
+  bookings;
+  freeze;
+  logger = new Logger2(_SubscriberChargeService.name);
+  constructor(ledger, contracts, subscribers, subscriptions, bookings = null, freeze = null) {
+    this.ledger = ledger;
+    this.contracts = contracts;
+    this.subscribers = subscribers;
+    this.subscriptions = subscriptions;
+    this.bookings = bookings;
+    this.freeze = freeze;
+  }
+  /**
+   * 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
+    });
+    return this.ledger.recordCharges(due);
+  }
+  /**
+   * 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;
+    }
+    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;
+    }
+    return this.contracts.list({
+      tenantId
+    });
+  }
+};
+SubscriberChargeService = _ts_decorate9([
+  Injectable6(),
+  _ts_param7(0, Inject7(SUBSCRIBER_LEDGER_REPOSITORY_TOKEN)),
+  _ts_param7(1, Inject7(SUBSCRIPTION_CONTRACT_REPOSITORY_TOKEN)),
+  _ts_param7(2, Inject7(SUBSCRIBER_REPOSITORY_TOKEN)),
+  _ts_param7(3, Inject7(SUBSCRIPTION_USAGE_PORT_TOKEN)),
+  _ts_param7(4, Optional5()),
+  _ts_param7(4, Inject7(SUBSCRIPTION_BUNDLE_REPOSITORY_TOKEN)),
+  _ts_param7(5, Optional5()),
+  _ts_param7(5, Inject7(CONTRACT_FREEZE_PORT_TOKEN)),
+  _ts_metadata7("design:type", Function),
+  _ts_metadata7("design:paramtypes", [
+    typeof SubscriberLedgerRepository === "undefined" ? Object : SubscriberLedgerRepository,
+    typeof SubscriptionContractRepository === "undefined" ? Object : SubscriptionContractRepository,
+    typeof SubscriberRepository === "undefined" ? Object : SubscriberRepository,
+    typeof SubscriptionUsagePort === "undefined" ? Object : SubscriptionUsagePort,
+    Object,
+    Object
+  ])
+], SubscriberChargeService);
+
+// src/billing/dto/tenant-billing.dto.ts
+import { IsISO8601, IsOptional, IsString, Matches } from "class-validator";
+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_decorate10, "_ts_decorate");
+function _ts_metadata8(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata8, "_ts_metadata");
 var PLAN_OR_CYCLE_PATTERN = /^[A-Z][A-Z0-9_]*$/;
 var PreviewPlanChangeDto = class {
   static {
@@ -1694,19 +2754,19 @@ var PreviewPlanChangeDto = class {
   plan;
   billingCycle;
 };
-_ts_decorate7([
+_ts_decorate10([
   IsString(),
   Matches(PLAN_OR_CYCLE_PATTERN, {
     message: "plan must be SCREAMING_SNAKE_CASE"
   }),
-  _ts_metadata5("design:type", String)
+  _ts_metadata8("design:type", String)
 ], PreviewPlanChangeDto.prototype, "plan", void 0);
-_ts_decorate7([
+_ts_decorate10([
   IsString(),
   Matches(PLAN_OR_CYCLE_PATTERN, {
     message: "billingCycle must be SCREAMING_SNAKE_CASE (e.g. MONTHLY, YEARLY)"
   }),
-  _ts_metadata5("design:type", String)
+  _ts_metadata8("design:type", String)
 ], PreviewPlanChangeDto.prototype, "billingCycle", void 0);
 var ChangePlanDto = class extends PreviewPlanChangeDto {
   static {
@@ -1731,25 +2791,25 @@ var CancelSubscriptionDto = class {
    */
   expectedEffectiveAt;
 };
-_ts_decorate7([
+_ts_decorate10([
   IsOptional(),
   IsISO8601(),
-  _ts_metadata5("design:type", String)
+  _ts_metadata8("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_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_decorate8, "_ts_decorate");
-function _ts_metadata6(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_metadata6, "_ts_metadata");
+__name(_ts_metadata9, "_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 +2829,52 @@ var CompleteOnboardingSubscriptionDto = class {
    */
   bundleVersionIds;
 };
-_ts_decorate8([
+_ts_decorate11([
   IsString2(),
   Matches2(PLAN_OR_CYCLE_PATTERN2, {
     message: "plan must be SCREAMING_SNAKE_CASE"
   }),
-  _ts_metadata6("design:type", String)
+  _ts_metadata9("design:type", String)
 ], CompleteOnboardingSubscriptionDto.prototype, "plan", void 0);
-_ts_decorate8([
+_ts_decorate11([
   IsString2(),
   Matches2(PLAN_OR_CYCLE_PATTERN2, {
     message: "billingCycle must be SCREAMING_SNAKE_CASE (e.g. MONTHLY, YEARLY)"
   }),
-  _ts_metadata6("design:type", String)
+  _ts_metadata9("design:type", String)
 ], CompleteOnboardingSubscriptionDto.prototype, "billingCycle", void 0);
-_ts_decorate8([
+_ts_decorate11([
   IsOptional2(),
   IsString2(),
   Matches2(PROMO_CODE_PATTERN, {
     message: 'promoCode must consist of A\u2013Z, 0\u20139, "-", "_" (4\u201332 characters)'
   }),
-  _ts_metadata6("design:type", String)
+  _ts_metadata9("design:type", String)
 ], CompleteOnboardingSubscriptionDto.prototype, "promoCode", void 0);
-_ts_decorate8([
+_ts_decorate11([
   IsOptional2(),
   IsArray(),
   ArrayMaxSize(10),
   IsUUID("all", {
     each: true
   }),
-  _ts_metadata6("design:type", Array)
+  _ts_metadata9("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_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_decorate9, "_ts_decorate");
-function _ts_metadata7(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_metadata7, "_ts_metadata");
+__name(_ts_metadata10, "_ts_metadata");
 var ISO_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}(T.*)?$/;
 var AddSubscriptionBundleDto = class {
   static {
@@ -1839,24 +2899,24 @@ var AddSubscriptionBundleDto = class {
    */
   billingCycle;
 };
-_ts_decorate9([
+_ts_decorate12([
   IsUUID2(),
-  _ts_metadata7("design:type", String)
+  _ts_metadata10("design:type", String)
 ], AddSubscriptionBundleDto.prototype, "bundleVersionId", void 0);
-_ts_decorate9([
+_ts_decorate12([
   IsOptional3(),
   IsInt(),
   Min(0),
   Max(120),
-  _ts_metadata7("design:type", Number)
+  _ts_metadata10("design:type", Number)
 ], AddSubscriptionBundleDto.prototype, "minimumTermMonths", void 0);
-_ts_decorate9([
+_ts_decorate12([
   IsOptional3(),
   IsIn([
     "MONTHLY",
     "YEARLY"
   ]),
-  _ts_metadata7("design:type", String)
+  _ts_metadata10("design:type", String)
 ], AddSubscriptionBundleDto.prototype, "billingCycle", void 0);
 var PreviewSubscriptionBundleDto = class {
   static {
@@ -1880,30 +2940,30 @@ var PreviewSubscriptionBundleDto = class {
    */
   billingCycle;
 };
-_ts_decorate9([
+_ts_decorate12([
   IsOptional3(),
   IsUUID2(),
-  _ts_metadata7("design:type", String)
+  _ts_metadata10("design:type", String)
 ], PreviewSubscriptionBundleDto.prototype, "bundleVersionId", void 0);
-_ts_decorate9([
+_ts_decorate12([
   IsOptional3(),
   IsUUID2(),
-  _ts_metadata7("design:type", String)
+  _ts_metadata10("design:type", String)
 ], PreviewSubscriptionBundleDto.prototype, "subscriptionBundleId", void 0);
-_ts_decorate9([
+_ts_decorate12([
   IsOptional3(),
   IsInt(),
   Min(0),
   Max(120),
-  _ts_metadata7("design:type", Number)
+  _ts_metadata10("design:type", Number)
 ], PreviewSubscriptionBundleDto.prototype, "minimumTermMonths", void 0);
-_ts_decorate9([
+_ts_decorate12([
   IsOptional3(),
   IsIn([
     "MONTHLY",
     "YEARLY"
   ]),
-  _ts_metadata7("design:type", String)
+  _ts_metadata10("design:type", String)
 ], PreviewSubscriptionBundleDto.prototype, "billingCycle", void 0);
 var CancelSubscriptionBundleDto = class {
   static {
@@ -1916,12 +2976,12 @@ var CancelSubscriptionBundleDto = class {
    */
   canceledAt;
 };
-_ts_decorate9([
+_ts_decorate12([
   IsOptional3(),
   Matches3(ISO_DATE_PATTERN, {
     message: "canceledAt must be an ISO date (YYYY-MM-DD)"
   }),
-  _ts_metadata7("design:type", String)
+  _ts_metadata10("design:type", String)
 ], CancelSubscriptionBundleDto.prototype, "canceledAt", void 0);
 var BundlePriceLookupDto = class {
   static {
@@ -1933,35 +2993,35 @@ var BundlePriceLookupDto = class {
    */
   bundleVersionIds;
 };
-_ts_decorate9([
+_ts_decorate12([
   IsArray2(),
   ArrayMaxSize2(BUNDLE_PRICE_LOOKUP_LIMIT),
   IsUUID2("4", {
     each: true
   }),
-  _ts_metadata7("design:type", Array)
+  _ts_metadata10("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 Inject8, Injectable as Injectable7, NotFoundException as NotFoundException2, Optional as Optional6, 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_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_decorate10, "_ts_decorate");
-function _ts_metadata8(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_metadata8, "_ts_metadata");
-function _ts_param5(paramIndex, decorator) {
+__name(_ts_metadata11, "_ts_metadata");
+function _ts_param8(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param5, "_ts_param");
+__name(_ts_param8, "_ts_param");
 var SubscriptionBundlesService = class {
   static {
     __name(this, "SubscriptionBundlesService");
@@ -2202,16 +3262,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_decorate13([
+  Injectable7(),
+  _ts_param8(0, Inject8(SUBSCRIPTION_BUNDLE_REPOSITORY_TOKEN)),
+  _ts_param8(1, Inject8(BUNDLE_REPOSITORY_TOKEN)),
+  _ts_param8(2, Optional6()),
+  _ts_param8(2, Inject8(SUBSCRIPTION_BUNDLE_CONFIG_TOKEN)),
+  _ts_param8(3, Optional6()),
+  _ts_param8(3, Inject8(SELF_SERVICE_BLOCKED_BUNDLES_TOKEN)),
+  _ts_metadata11("design:type", Function),
+  _ts_metadata11("design:paramtypes", [
     typeof SubscriptionBundleRepository === "undefined" ? Object : SubscriptionBundleRepository,
     typeof BundleRepository === "undefined" ? Object : BundleRepository,
     typeof SubscriptionBundleConfig === "undefined" ? Object : SubscriptionBundleConfig,
@@ -2243,25 +3303,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 Inject9, Logger as Logger3, ConflictException, NotFoundException as NotFoundException3, Optional as Optional7, 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_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_decorate11, "_ts_decorate");
-function _ts_metadata9(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_metadata9, "_ts_metadata");
-function _ts_param6(paramIndex, decorator) {
+__name(_ts_metadata12, "_ts_metadata");
+function _ts_param9(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param6, "_ts_param");
+__name(_ts_param9, "_ts_param");
 var TenantBillingController = class _TenantBillingController {
   static {
     __name(this, "TenantBillingController");
@@ -2282,7 +3355,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 +3373,9 @@ var TenantBillingController = class _TenantBillingController {
     this.contractFreeze = contractFreeze;
     this.trialProjection = trialProjection;
     this.cancellationNoticeDays = cancellationNoticeDays;
+    this.charges = charges;
   }
-  logger = new Logger2(_TenantBillingController.name);
+  logger = new Logger3(_TenantBillingController.name);
   // ---------------------------------------------------------------------
   // Reads (Phase B) — all authenticated tenant users
   // ---------------------------------------------------------------------
@@ -2456,7 +3531,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 +3562,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 +3735,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 +3774,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 +4054,117 @@ var TenantBillingController = class _TenantBillingController {
     }
   }
 };
-_ts_decorate11([
-  Get2("entitlement"),
-  _ts_param6(0, Req()),
-  _ts_metadata9("design:type", Function),
-  _ts_metadata9("design:paramtypes", [
+_ts_decorate14([
+  Get3("entitlement"),
+  _ts_param9(0, Req()),
+  _ts_metadata12("design:type", Function),
+  _ts_metadata12("design:paramtypes", [
     typeof RequestLike === "undefined" ? Object : RequestLike
   ]),
-  _ts_metadata9("design:returntype", Promise)
+  _ts_metadata12("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_decorate14([
+  Get3("usage"),
+  _ts_param9(0, Req()),
+  _ts_metadata12("design:type", Function),
+  _ts_metadata12("design:paramtypes", [
     typeof RequestLike === "undefined" ? Object : RequestLike
   ]),
-  _ts_metadata9("design:returntype", Promise)
+  _ts_metadata12("design:returntype", Promise)
 ], TenantBillingController.prototype, "getUsage", null);
-_ts_decorate11([
+_ts_decorate14([
   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_param9(0, Req()),
+  _ts_param9(1, Body()),
+  _ts_metadata12("design:type", Function),
+  _ts_metadata12("design:paramtypes", [
     typeof RequestLike === "undefined" ? Object : RequestLike,
     typeof PreviewPlanChangeDto === "undefined" ? Object : PreviewPlanChangeDto
   ]),
-  _ts_metadata9("design:returntype", Promise)
+  _ts_metadata12("design:returntype", Promise)
 ], TenantBillingController.prototype, "previewPlanChange", null);
-_ts_decorate11([
+_ts_decorate14([
   Post("plan"),
-  UseGuards(TenantAdminGuard),
-  _ts_param6(0, Req()),
-  _ts_param6(1, Body()),
-  _ts_metadata9("design:type", Function),
-  _ts_metadata9("design:paramtypes", [
+  UseGuards2(TenantAdminGuard),
+  _ts_param9(0, Req()),
+  _ts_param9(1, Body()),
+  _ts_metadata12("design:type", Function),
+  _ts_metadata12("design:paramtypes", [
     typeof RequestLike === "undefined" ? Object : RequestLike,
     typeof ChangePlanDto === "undefined" ? Object : ChangePlanDto
   ]),
-  _ts_metadata9("design:returntype", Promise)
+  _ts_metadata12("design:returntype", Promise)
 ], TenantBillingController.prototype, "changePlan", null);
-_ts_decorate11([
+_ts_decorate14([
   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_param9(0, Req()),
+  _ts_param9(1, Body()),
+  _ts_metadata12("design:type", Function),
+  _ts_metadata12("design:paramtypes", [
     typeof RequestLike === "undefined" ? Object : RequestLike,
     typeof CompleteOnboardingSubscriptionDto === "undefined" ? Object : CompleteOnboardingSubscriptionDto
   ]),
-  _ts_metadata9("design:returntype", Promise)
+  _ts_metadata12("design:returntype", Promise)
 ], TenantBillingController.prototype, "completeOnboardingSubscription", null);
-_ts_decorate11([
+_ts_decorate14([
   Post("subscription/accept-pending-version"),
-  UseGuards(TenantAdminGuard),
-  _ts_param6(0, Req()),
-  _ts_metadata9("design:type", Function),
-  _ts_metadata9("design:paramtypes", [
+  UseGuards2(TenantAdminGuard),
+  _ts_param9(0, Req()),
+  _ts_metadata12("design:type", Function),
+  _ts_metadata12("design:paramtypes", [
     typeof RequestLike === "undefined" ? Object : RequestLike
   ]),
-  _ts_metadata9("design:returntype", Promise)
+  _ts_metadata12("design:returntype", Promise)
 ], TenantBillingController.prototype, "acceptPendingPlanVersion", null);
-_ts_decorate11([
+_ts_decorate14([
   Post("cancel"),
-  UseGuards(TenantAdminGuard),
-  _ts_param6(0, Req()),
-  _ts_param6(1, Body()),
-  _ts_metadata9("design:type", Function),
-  _ts_metadata9("design:paramtypes", [
+  UseGuards2(TenantAdminGuard),
+  _ts_param9(0, Req()),
+  _ts_param9(1, Body()),
+  _ts_metadata12("design:type", Function),
+  _ts_metadata12("design:paramtypes", [
     typeof RequestLike === "undefined" ? Object : RequestLike,
     typeof CancelSubscriptionDto === "undefined" ? Object : CancelSubscriptionDto
   ]),
-  _ts_metadata9("design:returntype", Promise)
+  _ts_metadata12("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_decorate14([
+  Controller3("billing"),
+  UseGuards2(ComposedTenantAuthGuard),
+  _ts_param9(0, Inject9(ENTITLEMENT_SERVICE_TOKEN)),
+  _ts_param9(1, Inject9(PlanChangePreviewService)),
+  _ts_param9(2, Inject9(SUBSCRIPTION_USAGE_PORT_TOKEN)),
+  _ts_param9(3, Inject9(USAGE_SNAPSHOT_PORT_TOKEN)),
+  _ts_param9(4, Inject9(SUBSCRIPTION_WRITE_PORT_TOKEN)),
+  _ts_param9(5, Optional7()),
+  _ts_param9(5, Inject9(TENANT_ID_RESOLVER_TOKEN)),
+  _ts_param9(6, Optional7()),
+  _ts_param9(6, Inject9(USER_ID_RESOLVER_TOKEN)),
+  _ts_param9(7, Optional7()),
+  _ts_param9(7, Inject9(SELF_SERVICE_BLOCKED_PLANS_TOKEN)),
+  _ts_param9(8, Optional7()),
+  _ts_param9(8, Inject9(PromoCodesService)),
+  _ts_param9(9, Optional7()),
+  _ts_param9(9, Inject9(AdminAuditService)),
+  _ts_param9(10, Optional7()),
+  _ts_param9(10, Inject9(USER_EMAIL_RESOLVER_TOKEN)),
+  _ts_param9(11, Optional7()),
+  _ts_param9(11, Inject9(AUDIT_CONTEXT_RESOLVER_TOKEN)),
+  _ts_param9(12, Optional7()),
+  _ts_param9(12, Inject9(SubscriptionBundlesService)),
+  _ts_param9(13, Optional7()),
+  _ts_param9(13, Inject9(CONTRACT_FREEZE_PORT_TOKEN)),
+  _ts_param9(14, Optional7()),
+  _ts_param9(14, Inject9(TRIAL_PROJECTION_PORT_TOKEN)),
+  _ts_param9(15, Optional7()),
+  _ts_param9(15, Inject9(CANCELLATION_NOTICE_DAYS_TOKEN)),
+  _ts_param9(16, Optional7()),
+  _ts_param9(16, Inject9(SubscriberChargeService)),
+  _ts_metadata12("design:type", Function),
+  _ts_metadata12("design:paramtypes", [
     typeof EntitlementService === "undefined" ? Object : EntitlementService,
     typeof PlanChangePreviewService === "undefined" ? Object : PlanChangePreviewService,
     typeof SubscriptionUsagePort === "undefined" ? Object : SubscriptionUsagePort,
@@ -3100,20 +4180,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_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_decorate12, "_ts_decorate");
+__name(_ts_decorate15, "_ts_decorate");
 function settingFromCatalog(catalog, key) {
   const settings = catalog.tenantBilling;
   const value = settings?.[key];
@@ -3183,6 +4264,13 @@ var TenantBillingModule = class _TenantBillingModule {
         useClass: SubscriptionContractFreezeService
       });
     }
+    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({
         provide: TENANT_ID_RESOLVER_TOKEN,
@@ -3229,35 +4317,39 @@ var TenantBillingModule = class _TenantBillingModule {
         ...hasContractFreeze ? [
           CONTRACT_FREEZE_PORT_TOKEN
         ] : [],
+        ...hasChargeJournal ? [
+          SubscriberChargeService,
+          SubscriberAccountService
+        ] : [],
         ...options.extraExports ?? []
       ]
     };
   }
 };
-TenantBillingModule = _ts_decorate12([
-  Module2({})
+TenantBillingModule = _ts_decorate15([
+  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 Inject10, Injectable as Injectable8, NotFoundException as NotFoundException4, Optional as Optional8 } 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_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_decorate13, "_ts_decorate");
-function _ts_metadata10(k, v) {
+__name(_ts_decorate16, "_ts_decorate");
+function _ts_metadata13(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_metadata13, "_ts_metadata");
+function _ts_param10(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param7, "_ts_param");
+__name(_ts_param10, "_ts_param");
 var SubscriptionBundlePreviewService = class {
   static {
     __name(this, "SubscriptionBundlePreviewService");
@@ -3527,20 +4619,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_decorate16([
+  Injectable8(),
+  _ts_param10(0, Inject10(SUBSCRIPTION_BUNDLE_REPOSITORY_TOKEN)),
+  _ts_param10(1, Inject10(BUNDLE_REPOSITORY_TOKEN)),
+  _ts_param10(2, Optional8()),
+  _ts_param10(2, Inject10(PLAN_REPOSITORY_TOKEN)),
+  _ts_param10(3, Optional8()),
+  _ts_param10(3, Inject10(CATALOG_ENTRY_REPOSITORY_TOKEN)),
+  _ts_param10(4, Optional8()),
+  _ts_param10(4, Inject10(SELF_SERVICE_BLOCKED_BUNDLES_TOKEN)),
+  _ts_param10(5, Optional8()),
+  _ts_param10(5, Inject10(SUBSCRIPTION_BUNDLE_CONFIG_TOKEN)),
+  _ts_metadata13("design:type", Function),
+  _ts_metadata13("design:paramtypes", [
     typeof SubscriptionBundleRepository === "undefined" ? Object : SubscriptionBundleRepository,
     typeof BundleRepository === "undefined" ? Object : BundleRepository,
     Object,
@@ -3565,25 +4657,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 Inject11, Logger as Logger4, ConflictException as ConflictException2, NotFoundException as NotFoundException5, Optional as Optional9, 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_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_decorate14, "_ts_decorate");
-function _ts_metadata11(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_metadata11, "_ts_metadata");
-function _ts_param8(paramIndex, decorator) {
+__name(_ts_metadata14, "_ts_metadata");
+function _ts_param11(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param8, "_ts_param");
+__name(_ts_param11, "_ts_param");
+function planCycleOf2(sub) {
+  return sub.billingCycle;
+}
+__name(planCycleOf2, "planCycleOf");
 function buildTenantSubscriptionBundlesController(extraGuards = []) {
   let GeneratedTenantSubscriptionBundlesController = class GeneratedTenantSubscriptionBundlesController2 {
     static {
@@ -3594,19 +4690,21 @@ function buildTenantSubscriptionBundlesController(extraGuards = []) {
     subscriptionUsage;
     tenantIdResolver;
     contractFreeze;
-    logger = new Logger3("TenantSubscriptionBundlesController");
+    charges;
+    logger = new Logger4("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 +4734,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 +4744,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 +4761,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 +4871,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 +4883,96 @@ function buildTenantSubscriptionBundlesController(extraGuards = []) {
       }
     }
   };
-  _ts_decorate14([
-    Get3(),
-    _ts_param8(0, Req2()),
-    _ts_metadata11("design:type", Function),
-    _ts_metadata11("design:paramtypes", [
+  _ts_decorate17([
+    Get4(),
+    _ts_param11(0, Req2()),
+    _ts_metadata14("design:type", Function),
+    _ts_metadata14("design:paramtypes", [
       typeof RequestLike === "undefined" ? Object : RequestLike
     ]),
-    _ts_metadata11("design:returntype", Promise)
+    _ts_metadata14("design:returntype", Promise)
   ], GeneratedTenantSubscriptionBundlesController.prototype, "list", null);
-  _ts_decorate14([
+  _ts_decorate17([
     Post2("prices"),
-    _ts_param8(0, Req2()),
-    _ts_param8(1, Body2()),
-    _ts_metadata11("design:type", Function),
-    _ts_metadata11("design:paramtypes", [
+    _ts_param11(0, Req2()),
+    _ts_param11(1, Body2()),
+    _ts_metadata14("design:type", Function),
+    _ts_metadata14("design:paramtypes", [
       typeof RequestLike === "undefined" ? Object : RequestLike,
       typeof BundlePriceLookupDto === "undefined" ? Object : BundlePriceLookupDto
     ]),
-    _ts_metadata11("design:returntype", Promise)
+    _ts_metadata14("design:returntype", Promise)
   ], GeneratedTenantSubscriptionBundlesController.prototype, "prices", null);
-  _ts_decorate14([
+  _ts_decorate17([
     Post2(),
-    UseGuards2(TenantAdminGuard),
-    _ts_param8(0, Req2()),
-    _ts_param8(1, Body2()),
-    _ts_metadata11("design:type", Function),
-    _ts_metadata11("design:paramtypes", [
+    UseGuards3(TenantAdminGuard),
+    _ts_param11(0, Req2()),
+    _ts_param11(1, Body2()),
+    _ts_metadata14("design:type", Function),
+    _ts_metadata14("design:paramtypes", [
       typeof RequestLike === "undefined" ? Object : RequestLike,
       typeof AddSubscriptionBundleDto === "undefined" ? Object : AddSubscriptionBundleDto
     ]),
-    _ts_metadata11("design:returntype", Promise)
+    _ts_metadata14("design:returntype", Promise)
   ], GeneratedTenantSubscriptionBundlesController.prototype, "add", null);
-  _ts_decorate14([
+  _ts_decorate17([
     Post2("preview"),
     HttpCode2(HttpStatus2.OK),
-    _ts_param8(0, Req2()),
-    _ts_param8(1, Body2()),
-    _ts_metadata11("design:type", Function),
-    _ts_metadata11("design:paramtypes", [
+    _ts_param11(0, Req2()),
+    _ts_param11(1, Body2()),
+    _ts_metadata14("design:type", Function),
+    _ts_metadata14("design:paramtypes", [
       typeof RequestLike === "undefined" ? Object : RequestLike,
       typeof PreviewSubscriptionBundleDto === "undefined" ? Object : PreviewSubscriptionBundleDto
     ]),
-    _ts_metadata11("design:returntype", Promise)
+    _ts_metadata14("design:returntype", Promise)
   ], GeneratedTenantSubscriptionBundlesController.prototype, "preview", null);
-  _ts_decorate14([
+  _ts_decorate17([
     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_param11(0, Req2()),
+    _ts_param11(1, Param2("id", new ParseUUIDPipe())),
+    _ts_param11(2, Body2()),
+    _ts_metadata14("design:type", Function),
+    _ts_metadata14("design:paramtypes", [
       typeof RequestLike === "undefined" ? Object : RequestLike,
       String,
       typeof CancelSubscriptionBundleDto === "undefined" ? Object : CancelSubscriptionBundleDto
     ]),
-    _ts_metadata11("design:returntype", Promise)
+    _ts_metadata14("design:returntype", Promise)
   ], GeneratedTenantSubscriptionBundlesController.prototype, "cancel", null);
-  _ts_decorate14([
+  _ts_decorate17([
     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_param11(0, Req2()),
+    _ts_param11(1, Param2("id", new ParseUUIDPipe())),
+    _ts_metadata14("design:type", Function),
+    _ts_metadata14("design:paramtypes", [
       typeof RequestLike === "undefined" ? Object : RequestLike,
       String
     ]),
-    _ts_metadata11("design:returntype", Promise)
+    _ts_metadata14("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_decorate17([
+    Controller4("billing/subscription-bundles"),
+    UseGuards3(ComposedTenantAuthGuard, ...extraGuards),
+    _ts_param11(0, Inject11(SubscriptionBundlesService)),
+    _ts_param11(1, Inject11(SubscriptionBundlePreviewService)),
+    _ts_param11(2, Inject11(SUBSCRIPTION_USAGE_PORT_TOKEN)),
+    _ts_param11(3, Inject11(TENANT_ID_RESOLVER_TOKEN)),
+    _ts_param11(4, Optional9()),
+    _ts_param11(4, Inject11(CONTRACT_FREEZE_PORT_TOKEN)),
+    _ts_param11(5, Optional9()),
+    _ts_param11(5, Inject11(SubscriberChargeService)),
+    _ts_metadata14("design:type", Function),
+    _ts_metadata14("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 +4981,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_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_decorate15, "_ts_decorate");
+__name(_ts_decorate18, "_ts_decorate");
 var SubscriptionBundleModule = class _SubscriptionBundleModule {
   static {
     __name(this, "SubscriptionBundleModule");
@@ -3948,8 +5050,8 @@ var SubscriptionBundleModule = class _SubscriptionBundleModule {
     };
   }
 };
-SubscriptionBundleModule = _ts_decorate15([
-  Module3({})
+SubscriptionBundleModule = _ts_decorate18([
+  Module4({})
 ], SubscriptionBundleModule);
 
 export {
@@ -3989,11 +5091,16 @@ 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,
+  SUBSCRIBER_LEDGER_REPOSITORY_TOKEN,
+  SubscriberAccountService,
+  SubscriberAccountModule,
+  SubscriberChargeService,
   PreviewPlanChangeDto,
   ChangePlanDto,
   CancelSubscriptionDto,