@saasicat/core 1.0.0-rc.22 → 1.0.0-rc.24

package/dist/index.cjs

@@ -27,13 +27,20 @@ __export(index_exports, {
   CATALOGUE_KEYS: () => CATALOGUE_KEYS,
   CATALOG_ERROR_CODES: () => CATALOG_ERROR_CODES,
   CONTRACT_ERROR_CODES: () => CONTRACT_ERROR_CODES,
+  CUSTOM_LIMITS_KEYS: () => CUSTOM_LIMITS_KEYS,
   ERROR_MESSAGES_DE: () => ERROR_MESSAGES_DE,
   ERROR_MESSAGES_EN: () => ERROR_MESSAGES_EN,
   FEATURE_NOT_LICENSED: () => FEATURE_NOT_LICENSED,
   ForeignPaymentMethodReferenceError: () => ForeignPaymentMethodReferenceError,
   LEGAL_IDENTITY_FIELDS: () => LEGAL_IDENTITY_FIELDS,
+  MAINTENANCE_CAPABILITY: () => MAINTENANCE_CAPABILITY,
+  MAINTENANCE_ERROR_CODES: () => MAINTENANCE_ERROR_CODES,
+  MAINTENANCE_MESSAGE_MAX_LENGTH: () => MAINTENANCE_MESSAGE_MAX_LENGTH,
+  MAINTENANCE_STATE_MAX_AGE_SECONDS: () => MAINTENANCE_STATE_MAX_AGE_SECONDS,
   MARKETING_PRIORITY_MAX: () => MARKETING_PRIORITY_MAX,
   MARKETING_PRIORITY_MIN: () => MARKETING_PRIORITY_MIN,
+  NO_SCHEDULED_CHANGE: () => NO_SCHEDULED_CHANGE,
+  OPTIONAL_CANONICAL_MODELS: () => OPTIONAL_CANONICAL_MODELS,
   OTP_RATE_LIMIT_MAX_SENDS: () => OTP_RATE_LIMIT_MAX_SENDS,
   OTP_RATE_LIMIT_WINDOW_MINUTES: () => OTP_RATE_LIMIT_WINDOW_MINUTES,
   OTP_TTL_MINUTES: () => OTP_TTL_MINUTES,
@@ -48,62 +55,108 @@ __export(index_exports, {
   PROMO_ERROR_CODES: () => PROMO_ERROR_CODES,
   PaymentCallbackRejectedError: () => PaymentCallbackRejectedError,
   PersistenceCapabilityError: () => PersistenceCapabilityError,
+  PersistenceRefusal: () => PersistenceRefusal,
   PlatformUserExistsError: () => PlatformUserExistsError,
   REGISTRATION_ERROR_CODES: () => REGISTRATION_ERROR_CODES,
   REGISTRATION_RESUME_TTL_MINUTES: () => REGISTRATION_RESUME_TTL_MINUTES,
   REGISTRATION_STEP_BY_STATUS: () => REGISTRATION_STEP_BY_STATUS,
+  RETIREMENT_REMINDER_LEAD_DAYS: () => RETIREMENT_REMINDER_LEAD_DAYS,
   SETTINGS_ERROR_CODES: () => SETTINGS_ERROR_CODES,
   SETUP_ERROR_CODES: () => SETUP_ERROR_CODES,
   SUBSCRIBER_ACCOUNT_CAPABILITY: () => SUBSCRIBER_ACCOUNT_CAPABILITY,
   SUBSCRIBER_ERROR_CODES: () => SUBSCRIBER_ERROR_CODES,
+  VERSION_RETIREMENT_CAPABILITY: () => VERSION_RETIREMENT_CAPABILITY,
   applyPromo: () => applyPromo,
   assertPersistenceCapabilities: () => assertPersistenceCapabilities,
   buildActivePlanVersionWhere: () => buildActivePlanVersionWhere,
   buildActiveVersionWhere: () => buildActiveVersionWhere,
   buildFeatureRequiresIndex: () => buildFeatureRequiresIndex,
   bundleDraftDefaults: () => bundleDraftDefaults,
+  bundleKeyTaken: () => bundleKeyTaken,
   bundleStemDefaults: () => bundleStemDefaults,
   canonicalJson: () => canonicalJson,
+  catalogDraftExists: () => catalogDraftExists,
+  catalogVersionAlreadyPublished: () => catalogVersionAlreadyPublished,
+  catalogVersionGone: () => catalogVersionGone,
   classifyBundleVersionDiff: () => classifyBundleVersionDiff,
   classifyIssuerChange: () => classifyIssuerChange,
   classifyPlanDiff: () => classifyPlanDiff,
+  classifyVersionOffer: () => classifyVersionOffer,
   collectUnsatisfiedRequires: () => collectUnsatisfiedRequires,
+  computeIncludedVat: () => computeIncludedVat,
+  concurrencyGate: () => concurrencyGate,
+  concurrencyGateOf: () => concurrencyGateOf,
   contractPartiesOf: () => contractPartiesOf,
   coverageExcludingSelf: () => coverageExcludingSelf,
+  customLimitsReader: () => customLimitsReader,
   definedFields: () => definedFields,
   diffSettings: () => diffSettings,
   formatCustomerNumber: () => formatCustomerNumber,
   formatErrorMessage: () => formatErrorMessage,
+  grossFromNet: () => grossFromNet,
   identityCorrectionDelta: () => identityCorrectionDelta,
   isBundleRedundant: () => isBundleRedundant,
   isForeignPaymentMethodReferenceError: () => isForeignPaymentMethodReferenceError,
+  isMaintenanceAnnouncementLapsed: () => isMaintenanceAnnouncementLapsed,
+  isMaintenanceOverrun: () => isMaintenanceOverrun,
   isPaymentCallbackRejectedError: () => isPaymentCallbackRejectedError,
+  isPersistenceRefusal: () => isPersistenceRefusal,
   isPlatformUserExistsError: () => isPlatformUserExistsError,
+  isVersionActiveAt: () => isVersionActiveAt,
   isVersionEditable: () => isVersionEditable,
   issuerIdentityOf: () => issuerIdentityOf,
   keepOneRecommended: () => keepOneRecommended,
+  maintenanceRetryAfterSeconds: () => maintenanceRetryAfterSeconds,
+  maintenanceStatusOf: () => maintenanceStatusOf,
+  maintenanceWindowStatusOf: () => maintenanceWindowStatusOf,
+  maintenanceWindowViewOf: () => maintenanceWindowViewOf,
+  marketingProjectionTaken: () => marketingProjectionTaken,
+  membersLeftOut: () => membersLeftOut,
   missingRequiresFor: () => missingRequiresFor,
   movedIdentityFields: () => movedIdentityFields,
+  netFromGross: () => netFromGross,
+  noActivePlanVersion: () => noActivePlanVersion,
+  parseZonedInstant: () => parseZonedInstant,
+  percentOf: () => percentOf,
   pickActivePromo: () => pickActivePromo,
   planCatalogSettingsOf: () => planCatalogSettingsOf,
+  planKeyTaken: () => planKeyTaken,
+  planNotInCatalog: () => planNotInCatalog,
   previousUtcDay: () => previousUtcDay,
+  promoCodeTaken: () => promoCodeTaken,
   promoStatus: () => promoStatus,
   promotionOnPrice: () => promotionOnPrice,
+  prorate: () => prorate,
+  readCustomLimits: () => readCustomLimits,
   readQuotaRecord: () => readQuotaRecord,
   readQuotaValue: () => readQuotaValue,
   recordedIssuerIdentity: () => recordedIssuerIdentity,
   refuseForeignPaymentMethodReference: () => refuseForeignPaymentMethodReference,
   resolveBundleAvailability: () => resolveBundleAvailability,
   resolveErrorMessage: () => resolveErrorMessage,
+  retirementCostsTheSubscription: () => retirementCostsTheSubscription,
+  retirementReminderDueAt: () => retirementReminderDueAt,
+  retirementReminderIsDue: () => retirementReminderIsDue,
+  retirementSwitchTerms: () => retirementSwitchTerms,
+  roundToCents: () => roundToCents,
   sameLegalIdentity: () => sameLegalIdentity,
+  scheduledChangeAfterWrite: () => scheduledChangeAfterWrite,
   selectChargeableBundles: () => selectChargeableBundles,
   settingsSubtreeOf: () => settingsSubtreeOf,
   startOfUtcDay: () => startOfUtcDay,
   subscriberChargeColumns: () => subscriberChargeColumns,
   subscriberFromRegistration: () => subscriberFromRegistration,
   subscriberPaymentMethodColumns: () => subscriberPaymentMethodColumns,
+  subscriptionBundleAlreadyCancelled: () => subscriptionBundleAlreadyCancelled,
+  subscriptionBundleGone: () => subscriptionBundleGone,
+  subscriptionContractGone: () => subscriptionContractGone,
+  subscriptionGone: () => subscriptionGone,
+  sumToCents: () => sumToCents,
   toBundleStemRow: () => toBundleStemRow,
+  toCents: () => toCents,
   toContractLineItemRecord: () => toContractLineItemRecord,
+  toDecimalString: () => toDecimalString,
+  toMaintenanceWindowRecord: () => toMaintenanceWindowRecord,
   toPlanRow: () => toPlanRow,
   toPlanVersionRow: () => toPlanVersionRow,
   toRunningContractIssuer: () => toRunningContractIssuer,
@@ -112,7 +165,12 @@ __export(index_exports, {
   toSubscriberPaymentMethodRecord: () => toSubscriberPaymentMethodRecord,
   toSubscriberRecord: () => toSubscriberRecord,
   toSubscriptionBundleRecord: () => toSubscriptionBundleRecord,
-  toSubscriptionContractRecord: () => toSubscriptionContractRecord
+  toSubscriptionContractRecord: () => toSubscriptionContractRecord,
+  toSubscriptionNoticeRecord: () => toSubscriptionNoticeRecord,
+  toVersionRetirementRecord: () => toVersionRetirementRecord,
+  versionOnSale: () => versionOnSale,
+  versionOnSaleOrNext: () => versionOnSaleOrNext,
+  versionSale: () => versionSale
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -129,7 +187,8 @@ function buildActivePlanVersionWhere(asOf, options = {}) {
   const asOfDayStart = startOfUtcDay(asOf);
   const validityWindow = [
     { OR: [{ validFrom: null }, { validFrom: { lte: asOf } }] },
-    { OR: [{ validUntil: null }, { validUntil: { gte: asOfDayStart } }] }
+    { OR: [{ validUntil: null }, { validUntil: { gte: asOfDayStart } }] },
+    { OR: [{ supersededAt: null }, { validUntil: { not: null } }] }
   ];
   if (!options.withEndsAt) {
     return { publishedAt: { not: null }, AND: validityWindow };
@@ -139,6 +198,16 @@ function buildActivePlanVersionWhere(asOf, options = {}) {
     AND: [...validityWindow, { OR: [{ endsAt: null }, { endsAt: { gt: asOf } }] }]
   };
 }
+function isVersionActiveAt(version, asOf) {
+  const at = (value) => value === null || value === void 0 ? null : new Date(value);
+  const validFrom = at(version.validFrom);
+  const validUntil = at(version.validUntil);
+  const endsAt = at(version.endsAt);
+  if (validFrom && validFrom > asOf) return false;
+  if (validUntil && validUntil < startOfUtcDay(asOf)) return false;
+  if (version.supersededAt && !validUntil) return false;
+  return !(endsAt && endsAt <= asOf);
+}
 var buildActiveVersionWhere = buildActivePlanVersionWhere;
 
 // src/bundle-draft-defaults.ts
@@ -192,6 +261,79 @@ function definedFields(data, keys) {
 var MARKETING_PRIORITY_MIN = 0;
 var MARKETING_PRIORITY_MAX = 1e4;
 
+// src/money.ts
+var HUNDRED = { units: 100n, scale: 0 };
+function exactDecimal(value) {
+  if (!Number.isFinite(value)) {
+    throw new RangeError(`${String(value)} is not an amount money can be computed from.`);
+  }
+  const text = String(value);
+  const exponentAt = text.indexOf("e");
+  const mantissa = exponentAt === -1 ? text : text.slice(0, exponentAt);
+  const exponent = exponentAt === -1 ? 0 : Number(text.slice(exponentAt + 1));
+  const pointAt = mantissa.indexOf(".");
+  const whole = pointAt === -1 ? mantissa : mantissa.slice(0, pointAt);
+  const fraction = pointAt === -1 ? "" : mantissa.slice(pointAt + 1);
+  let units = BigInt(whole + fraction);
+  let scale = fraction.length - exponent;
+  if (scale < 0) {
+    units *= 10n ** BigInt(-scale);
+    scale = 0;
+  }
+  return { units, scale };
+}
+function sum(a, b) {
+  const scale = Math.max(a.scale, b.scale);
+  return {
+    units: a.units * 10n ** BigInt(scale - a.scale) + b.units * 10n ** BigInt(scale - b.scale),
+    scale
+  };
+}
+function roundHalfAwayFromZero(numerator, denominator) {
+  if (denominator === 0n) throw new RangeError("An amount cannot be divided by zero.");
+  const negative = numerator < 0n !== denominator < 0n;
+  const n = numerator < 0n ? -numerator : numerator;
+  const d = denominator < 0n ? -denominator : denominator;
+  const quotient = n / d;
+  const rounded = n % d * 2n >= d ? quotient + 1n : quotient;
+  return negative ? -rounded : rounded;
+}
+function cents(amount, factor, divisor) {
+  const numerator = amount.units * factor.units * 10n ** BigInt(divisor.scale) * 100n;
+  const denominator = divisor.units * 10n ** BigInt(amount.scale + factor.scale);
+  return roundHalfAwayFromZero(numerator, denominator);
+}
+function amountOf(inCents) {
+  return Number(inCents) / 100;
+}
+var ONE = { units: 1n, scale: 0 };
+function roundToCents(amount) {
+  return amountOf(cents(exactDecimal(amount), ONE, ONE));
+}
+function sumToCents(...terms) {
+  const total = terms.map(exactDecimal).reduce(sum, { units: 0n, scale: 0 });
+  return amountOf(cents(total, ONE, ONE));
+}
+function toCents(amount) {
+  return Number(cents(exactDecimal(amount), ONE, ONE));
+}
+function percentOf(amount, percent) {
+  return amountOf(cents(exactDecimal(amount), exactDecimal(percent), HUNDRED));
+}
+function prorate(amount, part, whole) {
+  return amountOf(cents(exactDecimal(amount), exactDecimal(part), exactDecimal(whole)));
+}
+function grossFromNet(net, vatRate) {
+  return amountOf(cents(exactDecimal(net), sum(HUNDRED, exactDecimal(vatRate)), HUNDRED));
+}
+function netFromGross(gross, vatRate) {
+  return amountOf(cents(exactDecimal(gross), HUNDRED, sum(HUNDRED, exactDecimal(vatRate))));
+}
+function computeIncludedVat(gross, vatRate) {
+  const rate = exactDecimal(vatRate);
+  return amountOf(cents(exactDecimal(gross), rate, sum(HUNDRED, rate)));
+}
+
 // src/promotion.types.ts
 function promoStatus(promo, today = /* @__PURE__ */ new Date()) {
   const from = new Date(promo.validFrom);
@@ -214,7 +356,9 @@ function boundedPromo(promo, basePrice) {
     const pct = withinBounds(promo.value, 100);
     return {
       kind: "percent",
-      discounted: Math.round(basePrice * (100 - pct)) / 100,
+      // The discount is rounded and taken off, as a promo code's is: two
+      // rules for one percentage would state two prices for it.
+      discounted: sumToCents(basePrice, -percentOf(basePrice, pct)),
       original: basePrice,
       pct
     };
@@ -223,7 +367,7 @@ function boundedPromo(promo, basePrice) {
     const saved = withinBounds(promo.value, basePrice);
     return {
       kind: "amount",
-      discounted: Math.round((basePrice - saved) * 100) / 100,
+      discounted: sumToCents(basePrice, -saved),
       original: basePrice,
       saved
     };
@@ -401,6 +545,286 @@ function appendNullableDecimalChange(out, field, oldValue, newValue, polarity) {
   appendDecimalChange(out, field, oldValue, newValue, polarity);
 }
 
+// src/version-offer.ts
+function takesSomethingAway(change) {
+  if (change.direction !== "REGRESSION") return false;
+  return change.field === "features.removed" || change.field.startsWith("quotas.");
+}
+function classifyVersionOffer(bound, candidate) {
+  const { changes } = classifyBundleVersionDiff(bound, candidate);
+  if (changes.some(takesSomethingAway)) return { class: "takes-something-away", changes };
+  if (changes.some((change) => change.direction === "REGRESSION")) {
+    return { class: "more-for-more", changes };
+  }
+  return { class: changes.length > 0 ? "improvement" : "same", changes };
+}
+
+// src/maintenance-window.types.ts
+var MAINTENANCE_MESSAGE_MAX_LENGTH = 500;
+var MAINTENANCE_STATE_MAX_AGE_SECONDS = 5;
+var MAINTENANCE_CAPABILITY = "maintenance.manage";
+
+// src/closed-value.ts
+function oneOf(allowed, value, source) {
+  const match = allowed.find((entry) => entry === value);
+  if (match === void 0) {
+    throw new Error(
+      `${source.table} row '${source.id}' holds ${source.column} '${value}', which is none of ${allowed.join(", ")}.`
+    );
+  }
+  return match;
+}
+
+// src/subscription-notice-mapping.ts
+var TABLE = "subscription_notices";
+var KINDS = {
+  "version-offered": true,
+  "version-retired": true,
+  "version-retirement-reminder": true
+};
+function toSubscriptionNoticeRecord(row) {
+  return {
+    id: row.id,
+    tenantId: row.tenantId,
+    subscriptionId: row.subscriptionId,
+    kind: oneOf(Object.keys(KINDS), row.kind, {
+      table: TABLE,
+      column: "kind",
+      id: row.id
+    }),
+    subject: row.subject,
+    content: row.content,
+    createdAt: row.createdAt,
+    claimedAt: row.claimedAt,
+    deliveredAt: row.deliveredAt,
+    delivery: row.deliveredAt === null ? null : deliveryOf(row)
+  };
+}
+function deliveryOf(row) {
+  const { recipients, channel } = row;
+  if (!Array.isArray(recipients) || !recipients.every((recipient) => typeof recipient === "string") || channel === null) {
+    throw new Error(
+      `${TABLE} row '${row.id}' is delivered, but its recipients are not a list of strings or its channel is missing.`
+    );
+  }
+  return { recipients: [...recipients], channel };
+}
+
+// src/version-sale.ts
+var DAY_MS = 24 * 60 * 60 * 1e3;
+function versionSale(version, now) {
+  if (!version.publishedAt) return { kind: "draft" };
+  if (isVersionActiveAt(version, now)) {
+    return { kind: "on-sale", until: lastDayOnSale(version) };
+  }
+  const start = dateOf(version.validFrom);
+  if (start && start > now && isVersionActiveAt(version, start)) {
+    return { kind: "scheduled", from: dayOf(start) };
+  }
+  return { kind: "off-sale", since: firstDayOffSale(version, now) };
+}
+function versionOnSale(versions, now) {
+  const onSale = versions.filter((v) => versionSale(v, now).kind === "on-sale");
+  const startOf = (v) => dateOf(v.validFrom)?.getTime() ?? -Infinity;
+  onSale.sort((a, b) => startOf(b) - startOf(a) || (b.version ?? 0) - (a.version ?? 0));
+  return onSale[0] ?? null;
+}
+function versionOnSaleOrNext(versions, now) {
+  const onSale = versionOnSale(versions, now);
+  if (onSale) return onSale;
+  const scheduled = versions.filter((v) => versionSale(v, now).kind === "scheduled");
+  const startOf = (v) => dateOf(v.validFrom)?.getTime() ?? Infinity;
+  scheduled.sort((a, b) => startOf(a) - startOf(b));
+  return scheduled[0] ?? null;
+}
+function lastDayOnSale(version) {
+  const days = [];
+  const validUntil = dateOf(version.validUntil);
+  if (validUntil) days.push(dayOf(validUntil));
+  const endsAt = dateOf(version.endsAt);
+  if (endsAt) days.push(dayOf(new Date(endsAt.getTime() - 1)));
+  return earliest(days);
+}
+function firstDayOffSale(version, now) {
+  const days = [];
+  const validUntil = dateOf(version.validUntil);
+  if (validUntil && dayOf(validUntil) < dayOf(now)) {
+    days.push(dayOf(new Date(validUntil.getTime() + DAY_MS)));
+  }
+  const endsAt = dateOf(version.endsAt);
+  if (endsAt && endsAt <= now) days.push(dayOf(new Date(endsAt.getTime() - 1 + DAY_MS)));
+  return earliest(days);
+}
+function earliest(days) {
+  return days.length === 0 ? null : days.reduce((a, b) => a < b ? a : b);
+}
+function dateOf(value) {
+  if (value === null || value === void 0) return null;
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? null : date;
+}
+function dayOf(date) {
+  return date.toISOString().slice(0, 10);
+}
+
+// src/version-retirement.types.ts
+var VERSION_RETIREMENT_CAPABILITY = "planVersions.retire";
+
+// src/version-retirement-mapping.ts
+function toVersionRetirementRecord(row) {
+  return {
+    id: row.id,
+    retired: {
+      planVersionId: row.retiredPlanVersionId,
+      planKey: row.retiredPlanKey,
+      version: row.retiredVersion
+    },
+    replacement: {
+      planVersionId: row.replacementPlanVersionId,
+      planKey: row.replacementPlanKey,
+      version: row.replacementVersion
+    },
+    announcedAt: row.announcedAt,
+    announcedBy: row.announcedBy
+  };
+}
+
+// src/scheduled-change-after-write.ts
+var NO_SCHEDULED_CHANGE = {
+  pendingPlan: null,
+  pendingBillingCycle: null,
+  pendingEffectiveAt: null,
+  pendingChangeVersionId: null
+};
+function scheduledChangeAfterWrite(current, input) {
+  if (!input.keepsPendingChange) return NO_SCHEDULED_CHANGE;
+  const movesOnlyTheRhythm = current.pendingPlan === current.plan && current.pendingChangeVersionId === null;
+  return movesOnlyTheRhythm && current.plan !== input.planId ? { pendingPlan: input.planId } : {};
+}
+
+// src/retirement-switch.ts
+function retirementSwitchTerms(notice, billingCycle) {
+  const priceIn = (side) => billingCycle === "YEARLY" ? side.yearlyNet : side.monthlyNet;
+  const replacement = priceIn(notice.replacement);
+  if (replacement === null) return null;
+  const retired = priceIn(notice.retired);
+  if (retired === null || replacement <= retired) return { priceNet: replacement, held: null };
+  return {
+    priceNet: replacement,
+    held: {
+      priceNet: retired,
+      amountNet: sumToCents(replacement, -retired),
+      // The last day to cancel without notice is the same day: the last
+      // whole one before the date the replacement takes over.
+      lastDay: notice.lastDayToCancel
+    }
+  };
+}
+
+// src/retirement-reminder.ts
+var RETIREMENT_REMINDER_LEAD_DAYS = 14;
+var DAY_MS2 = 24 * 60 * 60 * 1e3;
+function retirementReminderDueAt(notice) {
+  return new Date(Date.parse(notice.effectiveAt) - RETIREMENT_REMINDER_LEAD_DAYS * DAY_MS2);
+}
+function retirementReminderIsDue(notice, now) {
+  return retirementReminderDueAt(notice) <= now && now.getTime() < Date.parse(notice.effectiveAt);
+}
+function retirementCostsTheSubscription(notice, billingCycle) {
+  if (notice.changes.some(takesSomethingAway)) return true;
+  const terms = retirementSwitchTerms(notice, billingCycle);
+  return terms === null || terms.held !== null;
+}
+
+// src/maintenance-window-mapping.ts
+function toMaintenanceWindowRecord(row) {
+  return {
+    id: row.id,
+    startsAt: row.startsAt,
+    endsAt: row.endsAt,
+    message: row.message,
+    createdAt: row.createdAt,
+    createdBy: row.createdBy,
+    lockedAt: row.lockedAt,
+    lockedBy: row.lockedBy,
+    endedAt: row.endedAt,
+    endedBy: row.endedBy
+  };
+}
+
+// src/maintenance-window-views.ts
+var RETRY_AFTER_WITHOUT_END_SECONDS = 60;
+var iso = (date) => date ? date.toISOString() : null;
+function maintenanceWindowStatusOf(window) {
+  if (window.endedAt) return window.lockedAt ? "ended" : "cancelled";
+  return window.lockedAt ? "locked" : "announced";
+}
+function isMaintenanceOverrun(window, now) {
+  return maintenanceWindowStatusOf(window) === "locked" && window.endsAt !== null && window.endsAt.getTime() <= now.getTime();
+}
+function isMaintenanceAnnouncementLapsed(window, now) {
+  return maintenanceWindowStatusOf(window) === "announced" && window.endsAt !== null && window.endsAt.getTime() <= now.getTime();
+}
+function maintenanceStatusOf(open, now) {
+  if (!open) return { state: "none" };
+  const status = maintenanceWindowStatusOf(open);
+  if (status === "locked" && open.lockedAt) {
+    return {
+      state: "locked",
+      lockedAt: open.lockedAt.toISOString(),
+      endsAt: iso(open.endsAt),
+      message: open.message,
+      overrun: isMaintenanceOverrun(open, now)
+    };
+  }
+  if (status === "announced" && open.startsAt && open.endsAt && !isMaintenanceAnnouncementLapsed(open, now)) {
+    return {
+      state: "announced",
+      startsAt: open.startsAt.toISOString(),
+      endsAt: open.endsAt.toISOString(),
+      message: open.message
+    };
+  }
+  return { state: "none" };
+}
+function maintenanceWindowViewOf(window, now) {
+  return {
+    id: window.id,
+    status: maintenanceWindowStatusOf(window),
+    startsAt: iso(window.startsAt),
+    endsAt: iso(window.endsAt),
+    message: window.message,
+    createdAt: window.createdAt.toISOString(),
+    createdBy: window.createdBy,
+    lockedAt: iso(window.lockedAt),
+    lockedBy: window.lockedBy,
+    endedAt: iso(window.endedAt),
+    endedBy: window.endedBy,
+    overrun: isMaintenanceOverrun(window, now),
+    lapsed: isMaintenanceAnnouncementLapsed(window, now)
+  };
+}
+function maintenanceRetryAfterSeconds(window, now) {
+  if (!window.endsAt || window.endsAt.getTime() <= now.getTime()) {
+    return RETRY_AFTER_WITHOUT_END_SECONDS;
+  }
+  return Math.max(1, Math.ceil((window.endsAt.getTime() - now.getTime()) / 1e3));
+}
+
+// src/zoned-instant.ts
+function endsInOffset(text) {
+  const sign = text.charAt(text.length - 6);
+  return (sign === "+" || sign === "-") && text.charAt(text.length - 3) === ":";
+}
+function parseZonedInstant(text) {
+  const value = text.trim();
+  if (!value.includes("T")) return null;
+  const zoned = value.endsWith("Z") || value.endsWith("z") || endsInOffset(value);
+  if (!zoned) return null;
+  const moment = new Date(value);
+  return Number.isNaN(moment.getTime()) ? null : moment;
+}
+
 // src/settings-subtree.ts
 var CATALOGUE_KEYS = /* @__PURE__ */ new Set([
   "schemaVersion",
@@ -518,11 +942,42 @@ var CATALOG_ERROR_CODES = {
   PLAN_TERMINATE_INVALID_DATE: "PLAN_TERMINATE_INVALID_DATE",
   PLAN_TERMINATE_DATE_NOT_FUTURE: "PLAN_TERMINATE_DATE_NOT_FUTURE",
   PLAN_TERMINATE_NOT_IMPLEMENTED: "PLAN_TERMINATE_NOT_IMPLEMENTED",
+  /**
+   * Subscriptions told of a retirement still move onto this version, and
+   * nothing moves onto a version that has ended. Carries the version, its
+   * plan key and the first day it may end: the day after the last move.
+   */
+  PLAN_TERMINATE_BEFORE_RETIREMENT_MOVES: "PLAN_TERMINATE_BEFORE_RETIREMENT_MOVES",
+  /**
+   * Subscriptions told of a retirement are past their date and still to be
+   * moved onto this version — a move the platform could not make yet — so it
+   * cannot end until they have moved. Carries how many, the version and its
+   * plan key.
+   */
+  PLAN_TERMINATE_WHILE_MOVES_OVERDUE: "PLAN_TERMINATE_WHILE_MOVES_OVERDUE",
+  /**
+   * Subscriptions on a retired version have not yet been told of their move
+   * onto this version — their notice has reached nobody, so their date is not
+   * set — and it cannot end until they have been. Carries how many, the
+   * version and its plan key.
+   */
+  PLAN_TERMINATE_WHILE_NOTICES_UNDELIVERED: "PLAN_TERMINATE_WHILE_NOTICES_UNDELIVERED",
   // ── bundle versions ──
   BUNDLE_VERSION_ALREADY_PUBLISHED: "BUNDLE_VERSION_ALREADY_PUBLISHED",
   BUNDLE_VERSION_NOT_EDITABLE: "BUNDLE_VERSION_NOT_EDITABLE",
   BUNDLE_VERSION_NOT_PUBLISHED: "BUNDLE_VERSION_NOT_PUBLISHED",
   BUNDLE_VERSION_SUPERSEDED: "BUNDLE_VERSION_SUPERSEDED",
+  /**
+   * The bundle version is published, and its window has not opened: it goes
+   * on sale on `validFrom`, and until then its predecessor is the one sold.
+   */
+  BUNDLE_VERSION_NOT_YET_ON_SALE: "BUNDLE_VERSION_NOT_YET_ON_SALE",
+  /**
+   * The add-on itself has been deleted from the catalogue. Deleting it leaves
+   * its versions' dates as they were, so the version asked for can still be
+   * inside its window; it is not on offer all the same.
+   */
+  BUNDLE_DELETED: "BUNDLE_DELETED",
   BUNDLE_VERSION_REGRESSION: "BUNDLE_VERSION_REGRESSION",
   BUNDLE_VERSION_ZERO_PRICE: "BUNDLE_VERSION_ZERO_PRICE",
   BUNDLE_VERSION_NO_PRICE: "BUNDLE_VERSION_NO_PRICE",
@@ -581,6 +1036,22 @@ var BILLING_ERROR_CODES = {
   BUNDLE_NOT_SELF_SERVICE: "BUNDLE_NOT_SELF_SERVICE",
   BUNDLE_CYCLE_EXCEEDS_PLAN: "BUNDLE_CYCLE_EXCEEDS_PLAN",
   BUNDLE_NOT_PRICED_FOR_THIS_PLAN: "BUNDLE_NOT_PRICED_FOR_THIS_PLAN",
+  /**
+   * The bundle cannot run on a plan the subscription is already set to move
+   * to — by a scheduled change, or by a retirement it has been told of — and
+   * the booking would still be running then: that plan does not book it, or
+   * has no price for it. Carries that plan's key, the rhythm it is billed in
+   * there, and the day the move takes effect from, which can lie in the past
+   * while the move has not run yet.
+   */
+  BUNDLE_CANNOT_RUN_ON_UPCOMING_PLAN: "BUNDLE_CANNOT_RUN_ON_UPCOMING_PLAN",
+  /**
+   * As `BUNDLE_CANNOT_RUN_ON_UPCOMING_PLAN`, where only the rhythm stands in
+   * the way: a yearly bundle, and the subscription billed monthly from the
+   * day of the move — a switch of rhythm on the plan it keeps, for one, where
+   * naming the plan would point at the one it is already on. Same values.
+   */
+  BUNDLE_CANNOT_RUN_ON_UPCOMING_CYCLE: "BUNDLE_CANNOT_RUN_ON_UPCOMING_CYCLE",
   SUBSCRIPTION_BUNDLE_ALREADY_CANCELLED: "SUBSCRIPTION_BUNDLE_ALREADY_CANCELLED",
   SUBSCRIPTION_BUNDLE_NOT_CANCELLED: "SUBSCRIPTION_BUNDLE_NOT_CANCELLED",
   SUBSCRIPTION_BUNDLE_CANCELLATION_EFFECTIVE: "SUBSCRIPTION_BUNDLE_CANCELLATION_EFFECTIVE",
@@ -600,6 +1071,12 @@ var BILLING_ERROR_CODES = {
    * in it: a plan without a yearly price is a monthly plan.
    */
   PLAN_NOT_SOLD_IN_CYCLE: "PLAN_NOT_SOLD_IN_CYCLE",
+  /**
+   * The subscription is bound to a plan version the plan repository does not
+   * find, or finds as a version of another plan. What the subscription pays
+   * cannot be read, so no change is quoted until the binding is repaired.
+   */
+  BOUND_PLAN_VERSION_UNREADABLE: "BOUND_PLAN_VERSION_UNREADABLE",
   /** Plan change refused. Carries `blockers[]` with their own codes. */
   PLAN_CHANGE_BLOCKED: "PLAN_CHANGE_BLOCKED",
   /**
@@ -622,6 +1099,103 @@ var BILLING_ERROR_CODES = {
    * Carries the recomputed dates, so the page can re-ask instead of guessing.
    */
   CANCELLATION_TERMS_CHANGED: "CANCELLATION_TERMS_CHANGED",
+  /**
+   * The version the caller asked to switch to is no longer the one offered —
+   * another is on sale, the subscription moved, or there is no offer. Nothing
+   * was switched. Carries the current `offer`, or `null`, so the page can show
+   * it instead of guessing.
+   */
+  VERSION_OFFER_CHANGED: "VERSION_OFFER_CHANGED",
+  /**
+   * The version a change to another plan named is not the one on sale when
+   * the change was submitted: its preview was shown at another moment.
+   * Nothing was changed. Carries the current `preview`, so the page shows
+   * what the change binds now instead of what it would have.
+   */
+  PLAN_CHANGE_QUOTE_CHANGED: "PLAN_CHANGE_QUOTE_CHANGED",
+  /**
+   * A change to another plan named no version, where its preview names one:
+   * nothing says which price and terms the customer was shown, so nothing
+   * is changed.
+   */
+  PLAN_CHANGE_VERSION_NOT_NAMED: "PLAN_CHANGE_VERSION_NOT_NAMED",
+  /**
+   * A version that takes something away takes effect when the term ends, and
+   * the subscription's cancellation lands no later: the switch would never
+   * happen, so it is refused rather than recorded. Carries both dates.
+   */
+  VERSION_SWITCH_AFTER_CANCELLATION: "VERSION_SWITCH_AFTER_CANCELLATION",
+  /**
+   * A version that takes something away takes effect when the term ends, and
+   * it stops being sold before then — by its window or because an operator
+   * ended it — so it could not be bound when the change comes due. Refused
+   * rather than recorded; carries the dates.
+   */
+  VERSION_ENDS_BEFORE_SWITCH: "VERSION_ENDS_BEFORE_SWITCH",
+  // ── retiring a version for running subscriptions ──
+  /**
+   * The operator's terms are not confirmed to carry the clause a retirement
+   * rests on (`tenantBilling.orderlyRetirement.termsConfirmed` in
+   * `config/saas.yaml`), so none is accepted.
+   */
+  RETIREMENT_TERMS_NOT_CONFIRMED: "RETIREMENT_TERMS_NOT_CONFIRMED",
+  /**
+   * The version is still on sale: a subscription booked after the
+   * announcement would be on it without having been told. Carries the plan
+   * key and the version.
+   */
+  RETIREMENT_VERSION_ON_SALE: "RETIREMENT_VERSION_ON_SALE",
+  /** The replacement is not on sale, so nobody can continue on it. Carries plan key and version. */
+  RETIREMENT_REPLACEMENT_NOT_ON_SALE: "RETIREMENT_REPLACEMENT_NOT_ON_SALE",
+  /**
+   * The replacement has no price in the rhythm some of the subscriptions it
+   * reaches are billed in, so they cannot continue on it. Carries how many,
+   * and the replacement's plan key and version.
+   */
+  RETIREMENT_REPLACEMENT_NOT_SOLD_IN_RHYTHM: "RETIREMENT_REPLACEMENT_NOT_SOLD_IN_RHYTHM",
+  /**
+   * Some of the subscriptions the retirement reaches hold an add-on that
+   * cannot run on the replacement's plan, so they cannot continue on it.
+   * Carries how many, and the replacement's plan key and version.
+   */
+  RETIREMENT_REPLACEMENT_CANNOT_CARRY_BUNDLES: "RETIREMENT_REPLACEMENT_CANNOT_CARRY_BUNDLES",
+  /** The replacement named is the version being retired. */
+  RETIREMENT_REPLACEMENT_IS_RETIRED: "RETIREMENT_REPLACEMENT_IS_RETIRED",
+  /** No running subscription is on the version: there is nobody to tell. Carries plan key and version. */
+  RETIREMENT_NOTHING_AFFECTED: "RETIREMENT_NOTHING_AFFECTED",
+  /**
+   * Some of the subscriptions it reaches were reached by a retirement within
+   * the last twelve months, and a subscription is reached at most once in that
+   * time. Carries how many and which.
+   */
+  RETIREMENT_WITHIN_TWELVE_MONTHS: "RETIREMENT_WITHIN_TWELVE_MONTHS",
+  /**
+   * The subscriptions the retirement reaches, or their dates, changed since
+   * the preview the operator confirmed. Carries the preview as it stands.
+   */
+  RETIREMENT_PREVIEW_CHANGED: "RETIREMENT_PREVIEW_CHANGED",
+  /** No retirement of the subscription's version waits for its date: there is nothing to switch to. */
+  RETIREMENT_SWITCH_NOT_PENDING: "RETIREMENT_SWITCH_NOT_PENDING",
+  /** The switch opens once the trial has converted: a trial has no contract to hold the price on. */
+  RETIREMENT_SWITCH_IN_TRIAL: "RETIREMENT_SWITCH_IN_TRIAL",
+  /**
+   * An add-on running today cannot run beside the replacement's plan, which
+   * the switch would move the subscription onto today. Carries the add-on,
+   * the plan and the earliest day the booking can end. Its own code rather
+   * than a plan change's: the switch has no other plan to choose and no day
+   * to pick, so the way past it is the add-on ending.
+   */
+  RETIREMENT_SWITCH_BUNDLE_CANNOT_FOLLOW: "RETIREMENT_SWITCH_BUNDLE_CANNOT_FOLLOW",
+  /**
+   * The subscription takes no switch now: a change is scheduled, it has
+   * ended, or its plan is held for a special contract.
+   */
+  RETIREMENT_SWITCH_NOT_OPEN: "RETIREMENT_SWITCH_NOT_OPEN",
+  /**
+   * The version named is not the replacement the retirement names. Carries
+   * the retirement as it now stands.
+   */
+  RETIREMENT_SWITCH_CHANGED: "RETIREMENT_SWITCH_CHANGED",
   // ── the preview routes' own blockers and warnings ──
   //
   // These travel inside a 200 response, in `blockers[]` and `warnings[]`, not
@@ -651,14 +1225,23 @@ var BILLING_ERROR_CODES = {
   CANCELLATION_LOCKS_THE_CYCLE: "CANCELLATION_LOCKS_THE_CYCLE",
   /**
    * A bundle the tenant already holds runs past the cycle they are moving to.
+   * Carries the bundle, the earliest day the booking can end, and the two
+   * rhythms.
    *
    * Its own code rather than `BUNDLE_CYCLE_EXCEEDS_PLAN`, which states the
    * same rule about a booking that has not been made yet. The two need
    * different sentences: this one can name the day the obstacle lifts and
-   * tell the reader to cancel the booking, and that advice is wrong for
-   * someone who is only about to book. One template cannot serve both.
+   * tell the reader how to get past it, and that advice is wrong for someone
+   * who is only about to book. One template cannot serve both.
    */
   BUNDLE_BOOKING_OUTLASTS_TARGET_CYCLE: "BUNDLE_BOOKING_OUTLASTS_TARGET_CYCLE",
+  /**
+   * A bundle the tenant already holds cannot run on the plan they are moving
+   * to: that plan may not book it, or it has no price there in the rhythm
+   * the booking is billed in. Carries the bundle, the plan and the earliest
+   * day the booking can end.
+   */
+  BUNDLE_BOOKING_DOES_NOT_FIT_TARGET_PLAN: "BUNDLE_BOOKING_DOES_NOT_FIT_TARGET_PLAN",
   /**
    * Features of the previewed bundle are already covered by the plan or by
    * another booked bundle. A warning rather than a blocker: paying twice is
@@ -680,7 +1263,6 @@ var BILLING_ERROR_CODES = {
    * tenant reads and therefore needs a shipped text for.
    */
   BUNDLE_FEATURE_DEPENDENCY_UNSATISFIED: "BUNDLE_FEATURE_DEPENDENCY_UNSATISFIED",
-  NO_PENDING_PLAN_VERSION: "NO_PENDING_PLAN_VERSION",
   ONBOARDING_CREATE_FAILED: "ONBOARDING_CREATE_FAILED",
   BUNDLE_PREVIEW_ARGUMENT_AMBIGUOUS: "BUNDLE_PREVIEW_ARGUMENT_AMBIGUOUS",
   /**
@@ -731,7 +1313,15 @@ var CONTRACT_ERROR_CODES = {
   CHECKOUT_OFFER_CHANGED: "CHECKOUT_OFFER_CHANGED",
   SUBSCRIPTION_CONTRACT_NOT_FOUND: "SUBSCRIPTION_CONTRACT_NOT_FOUND",
   NO_ACTIVE_SUBSCRIPTION_CONTRACT: "NO_ACTIVE_SUBSCRIPTION_CONTRACT",
-  SUBSCRIPTION_CONTRACT_ALREADY_CLOSED: "SUBSCRIPTION_CONTRACT_ALREADY_CLOSED"
+  SUBSCRIPTION_CONTRACT_ALREADY_CLOSED: "SUBSCRIPTION_CONTRACT_ALREADY_CLOSED",
+  /**
+   * A successor would run beside another contract of the tenant: the
+   * contract in force moved while it was being written — another successor
+   * took its place, or a cancellation capped it — and kept moving on a
+   * second attempt, or a contract begins after the moment the successor
+   * would take effect. Nothing was written.
+   */
+  SUBSCRIPTION_CONTRACT_CHANGED: "SUBSCRIPTION_CONTRACT_CHANGED"
 };
 var SUBSCRIBER_ERROR_CODES = {
   /**
@@ -842,6 +1432,24 @@ var SETTINGS_ERROR_CODES = {
   /** No recorded change has this id, or the installation keeps no record at all. */
   SETTINGS_CHANGE_NOT_FOUND: "SETTINGS_CHANGE_NOT_FOUND"
 };
+var MAINTENANCE_ERROR_CODES = {
+  /** The application is locked for maintenance; the body carries the window. */
+  MAINTENANCE: "MAINTENANCE",
+  /** A window is already open: move or cancel it before announcing another. */
+  MAINTENANCE_WINDOW_ALREADY_OPEN: "MAINTENANCE_WINDOW_ALREADY_OPEN",
+  /** No open window has this id — it ended, or it never existed. */
+  MAINTENANCE_WINDOW_NOT_OPEN: "MAINTENANCE_WINDOW_NOT_OPEN",
+  /** The window is locked: its start is history, and unlocking is what ends it. */
+  MAINTENANCE_WINDOW_LOCKED: "MAINTENANCE_WINDOW_LOCKED",
+  /** The announced end is not after the announced start. */
+  MAINTENANCE_WINDOW_END_NOT_AFTER_START: "MAINTENANCE_WINDOW_END_NOT_AFTER_START",
+  /** The announced end has already passed. */
+  MAINTENANCE_WINDOW_END_IN_PAST: "MAINTENANCE_WINDOW_END_IN_PAST",
+  /** A time without its zone, or not a date and time at all; `field` names which. */
+  MAINTENANCE_TIME_INVALID: "MAINTENANCE_TIME_INVALID",
+  /** The message is longer than `MAINTENANCE_MESSAGE_MAX_LENGTH`. */
+  MAINTENANCE_MESSAGE_TOO_LONG: "MAINTENANCE_MESSAGE_TOO_LONG"
+};
 var PLATFORM_ERROR_CODES = {
   ...SETUP_ERROR_CODES,
   ...AUTH_ERROR_CODES,
@@ -852,7 +1460,8 @@ var PLATFORM_ERROR_CODES = {
   ...SUBSCRIBER_ERROR_CODES,
   ...REGISTRATION_ERROR_CODES,
   ...PAYMENT_ERROR_CODES,
-  ...SETTINGS_ERROR_CODES
+  ...SETTINGS_ERROR_CODES,
+  ...MAINTENANCE_ERROR_CODES
 };
 
 // src/errors.ts
@@ -871,121 +1480,555 @@ var PlatformUserExistsError = class extends Error {
 function isPlatformUserExistsError(err) {
   return err instanceof Error && err.code === USER_ALREADY_EXISTS;
 }
-
-// src/feature-requires.ts
-function buildFeatureRequiresIndex(features) {
-  const index = /* @__PURE__ */ new Map();
-  for (const feature of features) {
-    const requires = (feature.requires ?? []).filter((key) => key !== feature.featureKey);
-    if (requires.length > 0) index.set(feature.featureKey, requires);
-  }
-  return index;
-}
-function collectUnsatisfiedRequires(selected, index) {
-  const own = new Set(selected);
-  const unsatisfied = /* @__PURE__ */ new Set();
-  for (const featureKey of selected) {
-    for (const required of index.get(featureKey) ?? []) {
-      if (!own.has(required)) unsatisfied.add(required);
-    }
-  }
-  return [...unsatisfied].sort((a, b) => a.localeCompare(b));
-}
-function missingRequiresFor(bundle, coveredFeatures) {
-  const missing = (bundle.requiresFeatures ?? []).filter((key) => !coveredFeatures.has(key));
-  return [...new Set(missing)].sort((a, b) => a.localeCompare(b));
-}
-function resolveBundleAvailability(bundle, coveredFeatures) {
-  if (bundle.features.length > 0 && bundle.features.every((f) => coveredFeatures.has(f))) {
-    return "covered";
-  }
-  if (missingRequiresFor(bundle, coveredFeatures).length > 0) return "missing-requires";
-  return "bookable";
-}
-function coverageExcludingSelf(selfVersionId, planFeatures, selectedBundles) {
-  const covered = new Set(planFeatures);
-  for (const bundle of selectedBundles) {
-    if (bundle.bundleVersionId === selfVersionId) continue;
-    for (const feature of bundle.features) covered.add(feature);
+var PERSISTENCE_REFUSAL = "PersistenceRefusal";
+var PersistenceRefusal = class extends Error {
+  constructor(code, reason, message, params = {}) {
+    super(message);
+    this.code = code;
+    this.reason = reason;
+    this.params = params;
+    this.name = PERSISTENCE_REFUSAL;
   }
-  return covered;
-}
-function isBundleRedundant(bundle, planFeatures, selectedBundles) {
-  const covered = coverageExcludingSelf(bundle.bundleVersionId, planFeatures, selectedBundles);
-  return resolveBundleAvailability(bundle, covered) === "covered";
-}
-function compareSelectable(a, b) {
-  const orderA = a.sortOrder ?? Number.MAX_SAFE_INTEGER;
-  const orderB = b.sortOrder ?? Number.MAX_SAFE_INTEGER;
-  if (orderA !== orderB) return orderA - orderB;
-  return a.bundleVersionId.localeCompare(b.bundleVersionId);
+  code;
+  reason;
+  params;
+};
+function isPersistenceRefusal(err) {
+  if (!(err instanceof Error) || err.name !== PERSISTENCE_REFUSAL) return false;
+  const { code, reason } = err;
+  return typeof code === "string" && (reason === "gone" || reason === "moved");
 }
-function selectChargeableBundles(planFeatures, selectedBundles) {
-  const kept = [...selectedBundles].sort(compareSelectable);
-  for (; ; ) {
-    const redundantIndex = kept.findIndex(
-      (bundle) => isBundleRedundant(bundle, planFeatures, kept)
+
+// src/optional-canonical-models.ts
+var OPTIONAL_CANONICAL_MODELS = {
+  SuperAdminUser: ["core.superAdminProvisioning"],
+  SuperAdminMfa: ["core.mfa"],
+  AppliedSettings: ["core.appliedSettings"],
+  SettingsChange: ["core.appliedSettings"],
+  MaintenanceWindow: ["core.maintenanceWindows"],
+  SubscriptionNotice: ["tenantBilling.subscriptionNotices"],
+  VersionRetirement: ["tenantBilling.versionRetirements"],
+  SubscriberLedgerEntry: ["entitlement.subscriberLedgerRepository"],
+  PromoCodeHold: ["promo.holdRepository"]
+};
+function membersLeftOut(notAdopted = []) {
+  const unknown = notAdopted.filter((model) => !Object.hasOwn(OPTIONAL_CANONICAL_MODELS, model));
+  if (unknown.length > 0) {
+    throw new Error(
+      `notAdopted names ${unknown.join(", ")}, which the persistence bundle cannot leave out. It can leave out ${Object.keys(OPTIONAL_CANONICAL_MODELS).join(", ")}; for any other model it needs, pass your own adapter for the port that model serves.`
     );
-    if (redundantIndex === -1) return kept;
-    kept.splice(redundantIndex, 1);
   }
+  return new Set(
+    notAdopted.flatMap((model) => OPTIONAL_CANONICAL_MODELS[model])
+  );
 }
 
-// src/payment-gateway.types.ts
-var PAYMENT_CALLBACK_REJECTED = "PAYMENT_CALLBACK_REJECTED";
-var PaymentCallbackRejectedError = class extends Error {
-  code = PAYMENT_CALLBACK_REJECTED;
-  constructor(reason) {
-    super(`Payment callback rejected: ${reason}`);
-    this.name = "PaymentCallbackRejectedError";
+// src/concurrency-gate.ts
+function concurrencyGate(limit) {
+  if (!Number.isInteger(limit) || limit < 1) {
+    throw new RangeError(`A concurrency limit is a whole number of at least 1, not ${limit}.`);
   }
-};
-function isPaymentCallbackRejectedError(err) {
-  return err instanceof Error && err.code === PAYMENT_CALLBACK_REJECTED;
-}
-
-// src/registration.types.ts
-var PENDING_EMAIL_TTL_HOURS = 72;
-var PENDING_ONBOARDING_TTL_DAYS = 14;
-var PENDING_CHECKOUT_TTL_DAYS = 30;
-var OTP_TTL_MINUTES = 10;
-var PASSWORD_RESET_TTL_MINUTES = 30;
-var OTP_RATE_LIMIT_MAX_SENDS = 3;
-var OTP_RATE_LIMIT_WINDOW_MINUTES = 15;
-var OTP_VERIFY_MAX_ATTEMPTS = 5;
-var REGISTRATION_STEP_BY_STATUS = {
-  PENDING_EMAIL_VERIFICATION: 2,
-  EMAIL_VERIFIED: 3,
-  PLAN_SELECTED: 4,
-  CHECKOUT_STARTED: 4,
-  EXPIRED: 1,
-  DELETED: 1
-};
-var REGISTRATION_RESUME_TTL_MINUTES = 60;
-
-// src/plan-mapping.ts
-function toPlanRow(row) {
-  return {
-    id: row.id,
-    planKey: row.planKey,
-    label: row.label,
-    description: row.description,
-    icon: row.icon,
-    sortOrder: row.sortOrder,
-    createdAt: row.createdAt.toISOString(),
-    updatedAt: row.updatedAt.toISOString(),
-    deletedAt: toIsoOrNull(row.deletedAt)
+  let active = 0;
+  const waiting = [];
+  const release = () => {
+    const next = waiting.shift();
+    if (next) next();
+    else active -= 1;
+  };
+  return async (work) => {
+    if (active < limit) active += 1;
+    else await new Promise((admit) => waiting.push(admit));
+    try {
+      return await work();
+    } finally {
+      release();
+    }
   };
 }
-function toPlanVersionRow(row, planKey, fields) {
-  const mapped = {
-    id: row.id,
-    version: row.version,
-    baseVersionId: row.baseVersionId,
-    planId: planKey,
-    features: toFeatureKeys(row.features),
-    quotas: toQuotaEffects(row.quotas),
-    monthlyNet: String(row.monthlyNet),
+var GATES = /* @__PURE__ */ new WeakMap();
+function concurrencyGateOf(pool, limit) {
+  const known = GATES.get(pool);
+  if (known) {
+    if (known.limit !== limit) {
+      throw new RangeError(
+        `This pool is bounded at ${known.limit} transactions already; a second bound of ${limit} would split it.`
+      );
+    }
+    return known.gate;
+  }
+  const gate = concurrencyGate(limit);
+  GATES.set(pool, { limit, gate });
+  return gate;
+}
+
+// src/error-messages.ts
+var ERROR_MESSAGES_EN = {
+  // ── setup ──
+  SETUP_DISABLED: "{envVar} is not set \u2014 setup is disabled.",
+  INVALID_SETUP_TOKEN: "The setup token is not valid.",
+  SETUP_ALREADY_DONE: "Setup has already been completed.",
+  INVALID_EMAIL: "That is not a valid email address.",
+  EMAIL_EXISTS: "An account with this email address already exists.",
+  // ── auth ──
+  NOT_AUTHENTICATED: "Not authenticated",
+  NO_TENANT_ASSIGNED: "No tenant assigned",
+  TENANT_CONTEXT_MISSING: "No tenant ID found on the request",
+  TENANT_ADMIN_REQUIRED: "This action requires the TENANT_ADMIN role.",
+  BILLING_PERMISSION_REQUIRED: "This part of the billing area requires the billing permission.",
+  SUPER_ADMIN_REQUIRED: "Only the SUPER_ADMIN role is allowed",
+  MFA_NOT_SET_UP: "Run the MFA setup via the CLI first.",
+  MFA_REQUIRED: "TOTP code required in the X-Mfa-Code header.",
+  MFA_FAILED: "Invalid TOTP code.",
+  AUTH_GUARDS_NOT_CONFIGURED: "TenantBillingModule.forRoot.authGuards is not configured.",
+  // ── catalog ──
+  PLAN_HAS_DRAFTS: "Plan '{planKey}' still has {draftCount} open draft version(s). Discard them first (DELETE /admin/catalog/plan-versions/:id) or publish them.",
+  PLAN_HAS_PUBLISHED_VERSIONS: "Plan '{planKey}' cannot be {operation} \u2014 it has {publishedCount} published version(s) ({liveCount} live, {supersededCount} superseded). Existing subscriptions reference those versions (contract protection P1), so the plan record must be preserved.",
+  PLAN_HARD_DELETE_NOT_IMPLEMENTED: "Hard delete is not implemented in the current repository. Implement PlanRepository.hardDelete.",
+  PLAN_VERSION_ALREADY_PUBLISHED: "PlanVersion '{versionId}' is already published; it is not published again or discarded.",
+  PLAN_VERSION_NOT_EDITABLE: "PlanVersion '{versionId}' is not editable. Only drafts and published versions are editable that are latest-in-chain, bind no subscription yet, and whose validFrom lies in the future.",
+  PLAN_VERSION_REGRESSION: "This plan version is regressive (feature removed / quota lowered / price raised). Publishing requires an explicit `forceRegressive: true` (UI confirmation dialog with MFA).",
+  PLAN_VERSION_ZERO_PRICE: "A plan version cannot be published with a price of 0.00 (guard against seed placeholder). For deliberately free special contracts, set allowZeroPrice.",
+  PLAN_VERSION_DISCARD_NOT_IMPLEMENTED: "Discard is not implemented in the current repository. Implement PlanRepository.deletePlanVersionDraft.",
+  PLAN_VERSION_NOT_PUBLISHED: "PlanVersion '{versionId}' is not published and cannot be terminated.",
+  PLAN_VERSION_SUPERSEDED: "PlanVersion '{versionId}' has already been superseded by a newer version and cannot be terminated.",
+  PLAN_VERSION_VALID_FROM_REQUIRED: "validFrom must be set when publishing (on the draft or the publish call)..",
+  PLAN_VERSION_VALID_FROM_INVALID: "validFrom '{validFrom}' is not a day (YYYY-MM-DD)",
+  PLAN_VERSION_VALID_FROM_NOT_AFTER_PREVIOUS: "validFrom ({validFrom}) must be strictly after the validFrom of the previous version ({previousValidFrom}).",
+  PLAN_VERSION_VALID_FROM_NOT_GAPLESS: "The predecessor has validUntil={previousValidUntil} \u2014 the successor must start seamlessly on the next day ({requiredValidFrom}). Received: {received}.",
+  PLAN_VERSION_VALID_UNTIL_INVALID: "validUntil '{validUntil}' is not a day (YYYY-MM-DD)",
+  PLAN_VERSION_VALID_UNTIL_BEFORE_FROM: "validUntil ({validUntil}) must be strictly after validFrom ({validFrom}).",
+  PLAN_TERMINATE_INVALID_DATE: "endsAt is not a valid date.",
+  PLAN_TERMINATE_DATE_NOT_FUTURE: "endsAt ({endsAt}) must lie strictly in the future.",
+  PLAN_TERMINATE_NOT_IMPLEMENTED: "Terminate is not implemented in the current repository. Implement PlanRepository.terminate.",
+  PLAN_TERMINATE_BEFORE_RETIREMENT_MOVES: "Subscriptions still move to version {version} of {planKey}, so it can end on {date} at the earliest.",
+  PLAN_TERMINATE_WHILE_MOVES_OVERDUE: "{count} subscriptions are past their date and still to be moved to version {version} of {planKey}, so it cannot end until they have moved.",
+  PLAN_TERMINATE_WHILE_NOTICES_UNDELIVERED: "{count} subscriptions have not yet been told that they move to version {version} of {planKey}, so it cannot end until they have been.",
+  BUNDLE_VERSION_ALREADY_PUBLISHED: "BundleVersion '{versionId}' is already published; it is not published again or discarded.",
+  BUNDLE_VERSION_NOT_EDITABLE: "BundleVersion '{versionId}' is not editable. Only drafts and published versions are editable that are latest-in-chain, bind no subscription yet, and whose validFrom lies in the future.",
+  BUNDLE_VERSION_NOT_PUBLISHED: "BundleVersion '{bundleVersionId}' is not published and cannot be booked.",
+  BUNDLE_VERSION_SUPERSEDED: "BundleVersion '{bundleVersionId}' has been superseded by a newer version.",
+  BUNDLE_VERSION_NOT_YET_ON_SALE: "BundleVersion '{bundleVersionId}' goes on sale on {validFrom} and cannot be booked before.",
+  BUNDLE_DELETED: "Bundle '{bundleKey}' has been deleted from the catalogue and cannot be booked.",
+  BUNDLE_VERSION_REGRESSION: "This bundle version is regressive (feature removed / quota lowered / price raised). Publishing requires an explicit `forceRegressive: true` (UI confirmation dialog with MFA).",
+  BUNDLE_VERSION_ZERO_PRICE: "A bundle version cannot be published with an explicit price of 0.00 (guard against seed placeholders). For free bundles leave it null, or set allowZeroPrice.",
+  BUNDLE_VERSION_NO_PRICE: "This bundle version cannot be published without a price: neither a base price nor any plan override resolves one.",
+  BUNDLE_VERSION_NOT_PRICED_FOR_PLAN: "This bundle is offered to plan '{planKey}', which is sold {billingCycle}, and no {billingCycle} price resolves for it \u2014 neither a base price nor a plan override.",
+  BUNDLE_VERSION_DISCARD_NOT_IMPLEMENTED: "Discard is not implemented in the current repository. Implement BundleRepository.deleteDraft.",
+  BUNDLE_VERSION_VALID_FROM_REQUIRED: "Published bundle versions must keep a validFrom. Set a new future date, or edit the draft before publishing.",
+  BUNDLE_VERSION_VALID_FROM_INVALID: "validFrom '{validFrom}' is not a day (YYYY-MM-DD)",
+  BUNDLE_VERSION_VALID_FROM_NOT_AFTER_PREVIOUS: "validFrom ({validFrom}) must be strictly after the validFrom of the previous version ({previousValidFrom}).",
+  BUNDLE_VERSION_VALID_FROM_NOT_GAPLESS: "The predecessor has validUntil={previousValidUntil} \u2014 the successor must start seamlessly on the next day ({requiredValidFrom}). Received: {received}.",
+  BUNDLE_VERSION_VALID_FROM_NOT_FUTURE: "validFrom ({validFrom}) must, for a published-but-future bundle version, still lie in the future.",
+  BUNDLE_VERSION_VALID_UNTIL_INVALID: "validUntil '{validUntil}' is not a day (YYYY-MM-DD)",
+  BUNDLE_VERSION_VALID_UNTIL_BEFORE_FROM: "validUntil ({validUntil}) must be strictly after validFrom ({validFrom}).",
+  STRICT_MODE_VIOLATIONS: "The strict-mode check found drift against the discovery snapshot.",
+  PLAN_NOT_FOUND: "Plan '{planId}' not found",
+  PLAN_VERSION_NOT_FOUND: "PlanVersion '{versionId}' not found",
+  BUNDLE_NOT_FOUND: "Bundle '{bundleId}' not found",
+  BUNDLE_VERSION_NOT_FOUND: "BundleVersion '{bundleVersionId}' not found",
+  FEATURE_NOT_FOUND: "Feature '{featureKey}' not found",
+  QUOTA_NOT_FOUND: "Quota '{quotaKey}' not found",
+  PROMOTION_NOT_FOUND: "Promotion '{promotionId}' not found",
+  PROMOTION_VALUE_INVALID: "The value of a '{type}' promotion is not one its type takes: a percentage above 0 and at most 100, an amount above 0, an intro price of at least 0 for a whole number of months, or a whole number of free months.",
+  MARKETING_PROJECTION_NOT_FOUND: "MarketingProjection '{projectionId}' not found",
+  PLAN_ALREADY_EXISTS: "Plan '{planKey}' already exists",
+  BUNDLE_ALREADY_EXISTS: "Bundle '{bundleKey}' already exists",
+  MARKETING_PROJECTION_ALREADY_EXISTS: "Marketing projection for {targetType}/{targetVersionId}/{locale} already exists \u2014 use PATCH to edit it",
+  PLAN_DRAFT_ALREADY_EXISTS: "Plan '{planKey}' already has a draft version v{draftVersion}; publish or discard it first",
+  BUNDLE_DRAFT_ALREADY_EXISTS: "Bundle '{bundleKey}' already has a draft version v{draftVersion}; publish or discard it first",
+  QUOTA_NOT_IN_DISCOVERY_SNAPSHOT: "Quota '{quotaKey}' is not in the discovery snapshot \u2014 a quota that is not declared in code cannot be approved",
+  DISCOVERY_STATUS_TRANSITION_INVALID: "Transition '{from}' \u2192 '{to}' is not allowed",
+  DISCOVERY_NOT_INITIALIZED: "Approval requires a discovery snapshot \u2014 discovery is not initialised (#25)",
+  // ── catalogue import ──
+  PLAN_CATALOG_UNREADABLE: "That file is not a plan catalog \u2014 it could not be read as one. Check that it is the YAML your app declares its plans in.",
+  PLAN_CATALOG_INVALID: "The plan catalog was read, and then rejected: {message}",
+  // ── billing ──
+  BUNDLE_ALREADY_SUBSCRIBED: "Subscription '{subscriptionId}' has already actively booked this bundle.",
+  BUNDLE_INCOMPATIBLE_WITH_PLAN: "This bundle cannot be booked on the {planKey} plan. The plans that can book it: {allowedPlanKeys}.",
+  BUNDLE_NOT_SELF_SERVICE: "Bundle '{bundleKey}' is only activated via a special contract. Please contact the contract manager.",
+  BUNDLE_CYCLE_EXCEEDS_PLAN: "A yearly bundle cannot run beside a monthly plan: it would still be committed on every day the plan could end.",
+  BUNDLE_NOT_PRICED_FOR_THIS_PLAN: "This bundle has no price for the {planKey} plan in this billing cycle, so it cannot be booked from here.",
+  BUNDLE_CANNOT_RUN_ON_UPCOMING_PLAN: "This bundle cannot run on the {planKey} plan, which the subscription moves to with effect from {from}.",
+  BUNDLE_CANNOT_RUN_ON_UPCOMING_CYCLE: "A yearly bundle cannot run beside the monthly billing the subscription moves to with effect from {from}.",
+  SUBSCRIPTION_BUNDLE_ALREADY_CANCELLED: "SubscriptionBundle '{subscriptionBundleId}' is already cancelled.",
+  SUBSCRIPTION_BUNDLE_NOT_CANCELLED: "SubscriptionBundle '{subscriptionBundleId}' is not cancelled.",
+  SUBSCRIPTION_BUNDLE_CANCELLATION_EFFECTIVE: "Cancellation already in effect \u2014 book the bundle again.",
+  SUBSCRIPTION_NOT_FOUND: "No subscription for tenant {tenantId}",
+  SUBSCRIPTION_TENANT_MISMATCH: "Subscription does not belong to the tenant",
+  SUBSCRIPTION_BUNDLE_NOT_FOUND: "SubscriptionBundle '{subscriptionBundleId}' not found",
+  TENANT_NOT_FOUND: "Tenant {slug} not found",
+  NO_ACTIVE_PLAN_VERSION: "No version of plan {planId} is on sale as of {asOf}.",
+  BOUND_PLAN_VERSION_UNREADABLE: 'The plan version this subscription is bound to ({planVersionId}) cannot be read for plan "{planKey}", so no change can be quoted.',
+  PLAN_NOT_IN_CATALOG: 'Plan "{planKey}" is not in the catalog',
+  PLAN_NOT_SELF_SERVICE: "{planName} is only activated via a special contract. Please contact the contract manager.",
+  PLAN_NOT_SOLD_IN_CYCLE: "{planName} has no price for this billing rhythm and cannot be booked in it.",
+  PLAN_CHANGE_BLOCKED: "Plan change during onboarding is blocked.",
+  SUBSCRIPTION_CHANGED: "This subscription changed while the request was being decided. Reload it.",
+  NO_SUBSCRIPTION: "This tenant has no subscription to cancel.",
+  CANCELLATION_TERMS_CHANGED: "The effective date changed since it was shown. Confirm the new one.",
+  VERSION_OFFER_CHANGED: "The offer changed since it was shown. Look at the current one before switching.",
+  PLAN_CHANGE_QUOTE_CHANGED: "This plan changed since it was shown. Look at it again before changing to it.",
+  PLAN_CHANGE_VERSION_NOT_NAMED: "A plan change has to name the version its preview showed.",
+  VERSION_SWITCH_AFTER_CANCELLATION: "This subscription ends before this version would take effect, so it cannot be switched to.",
+  VERSION_ENDS_BEFORE_SWITCH: "This version stops being sold before it would take effect, so it cannot be switched to.",
+  RETIREMENT_TERMS_NOT_CONFIRMED: "Retiring a version for running subscriptions needs a clause in your terms. Set tenantBilling.orderlyRetirement.termsConfirmed in config/saas.yaml once they carry it.",
+  RETIREMENT_VERSION_ON_SALE: "Version {version} of {planKey} is still on sale. End its sale first, so nobody books it after the announcement.",
+  RETIREMENT_REPLACEMENT_NOT_ON_SALE: "Version {version} of {planKey} is not on sale, so subscriptions cannot continue on it.",
+  RETIREMENT_REPLACEMENT_NOT_SOLD_IN_RHYTHM: "{count} of these subscriptions are billed in a rhythm version {version} of {planKey} has no price for, so they cannot continue on it.",
+  RETIREMENT_REPLACEMENT_CANNOT_CARRY_BUNDLES: "{count} of these subscriptions hold a bundle that cannot run on version {version} of {planKey}, so they cannot continue on it.",
+  RETIREMENT_REPLACEMENT_IS_RETIRED: "A version cannot be its own replacement.",
+  RETIREMENT_NOTHING_AFFECTED: "No running subscription is on version {version} of {planKey}, so there is nobody to tell.",
+  RETIREMENT_WITHIN_TWELVE_MONTHS: "{count} of these subscriptions were reached by a retirement within the last twelve months. A subscription is reached at most once a year.",
+  RETIREMENT_PREVIEW_CHANGED: "The subscriptions this retirement reaches changed since they were shown. Look at them again before announcing it.",
+  RETIREMENT_SWITCH_NOT_PENDING: "No retirement of your version is waiting for its date, so there is nothing to switch to.",
+  RETIREMENT_SWITCH_IN_TRIAL: "The switch opens when your trial ends.",
+  RETIREMENT_SWITCH_BUNDLE_CANNOT_FOLLOW: "{bundleName} cannot run on {planName} and runs until {until} at the earliest. Once it is cancelled, the switch can be made from that day.",
+  RETIREMENT_SWITCH_NOT_OPEN: "This subscription cannot switch now: a change is scheduled, it has ended, or its plan is held for a special contract.",
+  RETIREMENT_SWITCH_CHANGED: "The retirement changed since it was shown. Look at it again before switching.",
+  SUBSCRIPTION_ENDED: "This subscription has ended. Its plan can no longer be changed.",
+  PLAN_LOCKED: "Active {planName} special contract \u2014 please contact the contract manager to change plans.",
+  QUOTA_OVER_TARGET: "Current usage {used} exceeds the target limit {targetMax} ({quotaKey}) in the {planName} plan. Please reduce usage first.",
+  FEATURE_LOST: "Switching means losing access to one feature. Existing data is retained and never deleted \u2014 upgrading again unlocks it.",
+  FEATURES_LOST: "Switching means losing access to {count} features. Existing data is retained and never deleted \u2014 upgrading again unlocks it.",
+  NO_CHANGE: "Target plan and billing cycle already match the current state.",
+  CANCELLATION_LOCKS_THE_CYCLE: "This subscription is cancelled, so its billing cycle cannot change. The plan can \u2014 keep the current cycle to change it today.",
+  CYCLE_SHORTENS_AT_TERM_END: "A monthly {planName} cannot start inside the yearly term you are in. The upgrade takes effect when that term ends; to have it today, keep the yearly cycle.",
+  BUNDLE_BOOKING_OUTLASTS_TARGET_CYCLE: "{bundleName} is billed yearly and runs until {until} at the earliest, which a monthly plan cannot carry. Once it is cancelled, a change that takes effect on or after that day goes through \u2014 or keep the yearly cycle.",
+  BUNDLE_BOOKING_DOES_NOT_FIT_TARGET_PLAN: "{bundleName} cannot run on {planName} and runs until {until} at the earliest. Once it is cancelled, a change that takes effect on or after that day goes through \u2014 or choose another plan.",
+  REDUNDANT_FEATURES: "The plan or another booked bundle already includes {count} of the features in this bundle \u2014 booking it pays for them twice.",
+  MINIMUM_TERM_BINDS: "The minimum term extends beyond the end of the period \u2014 the cancellation only takes effect when the minimum term ends.",
+  BUNDLE_FEATURE_DEPENDENCY_UNSATISFIED: "The bundle requires [{features}] \u2014 present neither in the plan nor in the active bundles.",
+  ONBOARDING_CREATE_FAILED: "The account could not be created. Please try again.",
+  BUNDLE_PREVIEW_ARGUMENT_AMBIGUOUS: "Exactly one of bundleVersionId (add preview) or subscriptionBundleId (cancel preview) must be given.",
+  SUBSCRIPTION_PK_MISSING: "The adapter returned a subscription usage record without an id. Pass the subscription primary key through (see SubscriptionUsageRecord.id).",
+  LIMIT_EXCEEDED: "The limit for {dimension} has been reached: {used} of {max}.",
+  QUOTA_DIMENSION_UNKNOWN: 'Unknown quota dimension "{dimension}".',
+  // ── promo ──
+  PROMO_CODE_NOT_FOUND: "Code not found",
+  PROMO_CODE_ALREADY_EXISTS: "The code exists, or a deleted code carries it; a deleted code keeps its name.",
+  PROMO_CODE_HAS_REDEMPTIONS: "The code already has redemptions, or checkouts holding one \u2014 it cannot be soft-deleted. Pause it instead.",
+  PROMO_CODE_NOT_REDEEMABLE: "Code cannot be redeemed: {reason}",
+  PROMO_CODE_FORMAT_INVALID: 'The code may only contain upper-case letters, digits, "-" and "_" (4\u201332 characters).',
+  PROMO_PERCENT_OUT_OF_RANGE: "The percentage must be between 0 and 100.",
+  PROMO_AMOUNT_NOT_POSITIVE: "The amount must be positive.",
+  PROMO_ONE_OFF_WITH_DURATION: "A one-off discount must not set a duration.",
+  PROMO_DURATION_INVALID: "Invalid duration (at most 24 months or billing periods).",
+  PROMO_VALIDITY_WINDOW_INVALID: "Invalid validity window.",
+  PROMO_PLAN_NOT_DISCOUNTABLE: "{plan}-Plan cannot be discounted.",
+  PROMO_MIN_AMOUNT_NOT_POSITIVE: "The minimum plan gross amount must be positive.",
+  PROMO_WOULD_PRODUCE_ZERO_INVOICE: "For absolute amounts the discount must stay below the lowest applicable plan price, or allowZeroInvoice must be enabled.",
+  PROMO_MAX_REDEMPTIONS_LOWERED: "maxRedemptions cannot be lowered.",
+  // ── contract ──
+  CHECKOUT_OFFER_LINE_ITEMS_REQUIRED: "A checkout offer can yield only one contract, and only once its line items are frozen.",
+  CHECKOUT_OFFER_PLAN_LINE_ITEM_REQUIRED: "A checkout offer requires a frozen plan line item.",
+  CHECKOUT_OFFER_BUNDLE_LINE_ITEMS_REQUIRED: "Every selected bundle version requires a frozen bundle line item.",
+  CHECKOUT_OFFER_BUNDLE_VERSION_NOT_BOOKABLE: "At least one bundle version from the checkout offer is no longer bookable.",
+  CHECKOUT_OFFER_FEATURE_DEPENDENCY_UNSATISFIED: "The selected plan does not cover all feature dependencies: [{missingRequires}] are missing from the plan + selected bundles.",
+  CHECKOUT_OFFER_PLAN_NOT_OFFERED: "Plan '{planKey}' is not offered with a {billingCycle} price at the moment.",
+  CHECKOUT_OFFER_BUNDLE_NOT_OFFERED: "Bundle version '{bundleVersionId}' cannot be added to this offer ({reason}).",
+  CHECKOUT_OFFER_PROMO_CODE_NOT_ACCEPTED: "The promo code cannot be applied to this offer ({reason}).",
+  CHECKOUT_OFFER_PRICE_NOT_CURRENT: "The prices of checkout offer '{offerId}' no longer match the catalogue; create a new offer.",
+  SUBSCRIPTION_CONTRACT_LINE_ITEMS_REQUIRED: "A subscription contract requires at least one line item.",
+  SUBSCRIPTION_CONTRACT_PLAN_LINE_ITEM_REQUIRED: "A subscription contract requires exactly one plan base item.",
+  SUBSCRIPTION_CONTRACT_INVALID_DATE: "{field} must be a valid date.",
+  SUBSCRIPTION_CONTRACT_INVALID_WINDOW: "effectiveUntil must be after effectiveFrom.",
+  SUBSCRIPTION_CONTRACT_LINE_ITEM_TAX_MISMATCH: "A line item's taxAmount must be exactly priceGross minus priceNet.",
+  SUBSCRIPTION_CONTRACT_TAX_RATE_NOT_PERCENT: "A subscription contract states a tax rate of {taxRate} at {field}, which is not a percentage: a rate lies from 0 to 100, and a value between 0 and 1 is refused as a fraction.",
+  SUBSCRIPTION_CONTRACT_TERMINATION_BEFORE_START: "effectiveUntil must be after the effectiveFrom of the contract.",
+  SUBSCRIPTION_CONTRACT_LINE_ITEM_CURRENCY_MISMATCH: "A line item must be booked in the currency its contract was priced in.",
+  SUBSCRIPTION_CONTRACT_LINES_DO_NOT_ADD_UP: "The line items of a subscription contract add up to {lines} for {field}, but the contract states {stated}.",
+  SUBSCRIPTION_CONTRACT_DISCOUNT_NEGATIVE: "A subscription contract states a discount of {amount} at {field}; a discount takes money off and is never negative.",
+  CHECKOUT_OFFER_NOT_FOUND: "CheckoutOffer '{offerId}' not found",
+  CHECKOUT_OFFER_EXPIRED: "Checkout offer '{offerId}' has expired and cannot be {action}",
+  CHECKOUT_OFFER_ALREADY_CONSUMED: "Checkout offer '{offerId}' has already been consumed and cannot be {action}",
+  CHECKOUT_OFFER_NOT_CONSUMED: "CheckoutOffer '{offerId}' must be consumed before the contract is created",
+  CHECKOUT_OFFER_CHANGED: "Checkout offer '{offerId}' changed while it was being concluded. Load it again.",
+  SUBSCRIPTION_CONTRACT_NOT_FOUND: "SubscriptionContract '{contractId}' not found",
+  NO_ACTIVE_SUBSCRIPTION_CONTRACT: "No active subscription contract for tenant {tenantId}",
+  SUBSCRIPTION_CONTRACT_ALREADY_CLOSED: "SubscriptionContract '{contractId}' is already closed",
+  SUBSCRIPTION_CONTRACT_CHANGED: "The contracts of tenant '{tenantId}' changed while a successor was being written, or one begins after the moment it would take effect, so it would run beside another. Nothing was written.",
+  // ── subscriber ──
+  SUBSCRIBER_REQUIRED: "Tenant '{tenantId}' has no subscriber. Nothing is agreed or charged without the party to it: create the tenant's subscriber first.",
+  SUBSCRIBER_ALREADY_EXISTS: "Tenant '{tenantId}' already has a subscriber.",
+  SUBSCRIBER_NOT_FOUND: "Subscriber '{subscriberId}' not found",
+  SUBSCRIBER_LEGAL_NAME_REQUIRED: "A subscriber needs its legal name.",
+  SUBSCRIBER_DETAIL_INVALID: "The subscriber's {field} is not valid.",
+  SUBSCRIBER_IDENTITY_NOT_A_CONTACT: "{field} is part of the subscriber's legal identity and changes only as a correction, with a reason.",
+  SUBSCRIBER_CORRECTION_REASON_REQUIRED: "A correction of the legal identity needs a reason.",
+  SUBSCRIBER_CORRECTION_ACTOR_REQUIRED: "A correction of the legal identity has to say who makes it.",
+  SUBSCRIBER_CORRECTION_CHANGES_NOTHING: "The correction changes nothing: every value it names is already recorded.",
+  SUBSCRIBER_TAKEOVER_IS_A_TRANSFER: "Another legal entity taking over a subscriber is a transfer, not a correction, and cannot be recorded as an edit.",
+  // ── registration ──
+  PENDING_REGISTRATION_NOT_FOUND: "This registration could not be found. It may have already been completed or discarded.",
+  PENDING_REGISTRATION_EXPIRED: "This registration has expired. Please start again.",
+  INVALID_REGISTRATION_STATE: "This step is not available at the current stage of the registration.",
+  OTP_INVALID: "That code is not correct. Please check it and try again.",
+  OTP_EXPIRED: "That code has expired. Please request a new one.",
+  OTP_LOCKED: "Too many incorrect attempts. Please request a new code.",
+  RATE_LIMITED: "Too many attempts. Please try again in {retryAfterSeconds} seconds.",
+  RESUME_TOKEN_INVALID: "This resume link is no longer valid. Please request a new one.",
+  RESUME_NOT_CONFIGURED: "Resuming a registration is not available.",
+  CONFIGURATOR_NOT_CONFIGURED: "The configurator is not available.",
+  CONFIG_NOT_SAVED: "The configuration could not be saved.",
+  PLAN_NOT_AVAILABLE: "This plan is not available.",
+  PLAN_NOT_SELECTED: "Please select a plan first.",
+  MODEL_NOT_AVAILABLE: "This option is not available.",
+  // ── payments ──
+  PAYMENTS_NOT_CONFIGURED: "Payment methods cannot be set up here yet.",
+  PAYMENT_GATEWAY_ACCOUNT_UNKNOWN: "No payment gateway account is configured under '{account}'.",
+  PAYMENT_CALLBACK_REJECTED: "The payment callback could not be verified.",
+  PAYMENT_RETURN_URL_NOT_ALLOWED: "The {field} leads to a site this installation does not return to.",
+  PAYMENT_GATEWAY_FAILED: "The payment provider did not answer as expected. Please try again in a few minutes.",
+  // ── entitlement (code lives in upsell.types.ts) ──
+  [FEATURE_NOT_LICENSED]: "Feature {featureKeys} is not included in the current plan.",
+  // ── settings ──
+  SETTINGS_CHANGE_NOT_FOUND: "No recorded settings change has this id.",
+  // ── maintenance ──
+  MAINTENANCE: "The application is under maintenance.",
+  MAINTENANCE_WINDOW_ALREADY_OPEN: "A maintenance window is already open. Move or cancel it before announcing another.",
+  MAINTENANCE_WINDOW_NOT_OPEN: "No open maintenance window has this id.",
+  MAINTENANCE_WINDOW_LOCKED: "This maintenance window is locked. Its start cannot move, and unlocking is what ends it.",
+  MAINTENANCE_WINDOW_END_NOT_AFTER_START: "The end of a maintenance window has to be after its start.",
+  MAINTENANCE_WINDOW_END_IN_PAST: "The end of a maintenance window cannot be in the past.",
+  MAINTENANCE_TIME_INVALID: "The {field} has to be a date and time with its zone, such as 2026-10-02T22:00+02:00.",
+  MAINTENANCE_MESSAGE_TOO_LONG: "The message may be at most {max} characters long."
+};
+function formatErrorMessage(template, params = {}) {
+  return template.replace(/\{(\w+)\}/g, (match, name) => {
+    const value = params[name];
+    return value === void 0 || value === null ? match : String(value);
+  });
+}
+function resolveErrorMessage(body, overrides = {}, defaults = ERROR_MESSAGES_EN) {
+  const code = typeof body.code === "string" ? body.code : void 0;
+  const template = (code && (overrides[code] ?? defaults[code])) ?? void 0;
+  if (!template) {
+    return typeof body.message === "string" ? body.message : code ?? "";
+  }
+  const { params, ...rest } = body;
+  return formatErrorMessage(template, { ...rest, ...params });
+}
+
+// src/refusal.ts
+function refusal(code, reason, params) {
+  return new PersistenceRefusal(
+    code,
+    reason,
+    formatErrorMessage(ERROR_MESSAGES_EN[code], params),
+    params
+  );
+}
+
+// src/catalog-version-refusals.ts
+var CASES = {
+  PlanVersion: {
+    gone: { code: CATALOG_ERROR_CODES.PLAN_VERSION_NOT_FOUND, param: "versionId" },
+    published: { code: CATALOG_ERROR_CODES.PLAN_VERSION_ALREADY_PUBLISHED, param: "versionId" },
+    draft: { code: CATALOG_ERROR_CODES.PLAN_DRAFT_ALREADY_EXISTS, param: "planKey" }
+  },
+  BundleVersion: {
+    gone: { code: CATALOG_ERROR_CODES.BUNDLE_VERSION_NOT_FOUND, param: "bundleVersionId" },
+    published: {
+      code: CATALOG_ERROR_CODES.BUNDLE_VERSION_ALREADY_PUBLISHED,
+      param: "versionId"
+    },
+    draft: { code: CATALOG_ERROR_CODES.BUNDLE_DRAFT_ALREADY_EXISTS, param: "bundleKey" }
+  }
+};
+function catalogVersionGone(kind, versionId) {
+  const { code, param } = CASES[kind].gone;
+  return new PersistenceRefusal(code, "gone", `${kind} '${versionId}' not found.`, {
+    [param]: versionId
+  });
+}
+function catalogVersionAlreadyPublished(kind, versionId) {
+  const { code, param } = CASES[kind].published;
+  return new PersistenceRefusal(
+    code,
+    "moved",
+    `${kind} '${versionId}' is already published; it is not published again or discarded.`,
+    { [param]: versionId }
+  );
+}
+function catalogDraftExists(kind, key, draftVersion) {
+  const { code, param } = CASES[kind].draft;
+  return refusal(code, "moved", { [param]: key, draftVersion });
+}
+
+// src/catalog-key-refusals.ts
+function planKeyTaken(planKey) {
+  return refusal(CATALOG_ERROR_CODES.PLAN_ALREADY_EXISTS, "moved", { planKey });
+}
+function bundleKeyTaken(bundleKey) {
+  return refusal(CATALOG_ERROR_CODES.BUNDLE_ALREADY_EXISTS, "moved", { bundleKey });
+}
+function marketingProjectionTaken(target) {
+  return refusal(CATALOG_ERROR_CODES.MARKETING_PROJECTION_ALREADY_EXISTS, "moved", {
+    targetType: target.targetType,
+    targetVersionId: target.targetVersionId,
+    locale: target.locale
+  });
+}
+
+// src/decimal-string.ts
+function toDecimalString(value) {
+  if (!Number.isFinite(value)) {
+    throw new RangeError(`${String(value)} is not an amount a numeric column can hold.`);
+  }
+  return String(value);
+}
+
+// src/promo-code-refusals.ts
+function promoCodeTaken(code) {
+  return new PersistenceRefusal(
+    PROMO_ERROR_CODES.PROMO_CODE_ALREADY_EXISTS,
+    "moved",
+    `Promo code '${code}' is taken.`,
+    { promoCode: code }
+  );
+}
+
+// src/subscription-refusals.ts
+function subscriptionGone(tenantId) {
+  return refusal(BILLING_ERROR_CODES.SUBSCRIPTION_NOT_FOUND, "gone", { tenantId });
+}
+function noActivePlanVersion(planId, asOf) {
+  return refusal(BILLING_ERROR_CODES.NO_ACTIVE_PLAN_VERSION, "gone", {
+    planId,
+    asOf: asOf.toISOString().slice(0, 10)
+  });
+}
+function planNotInCatalog(planKey) {
+  return refusal(BILLING_ERROR_CODES.PLAN_NOT_IN_CATALOG, "gone", { planKey });
+}
+function subscriptionBundleGone(subscriptionBundleId) {
+  return refusal(BILLING_ERROR_CODES.SUBSCRIPTION_BUNDLE_NOT_FOUND, "gone", {
+    subscriptionBundleId
+  });
+}
+function subscriptionBundleAlreadyCancelled(subscriptionBundleId) {
+  return refusal(BILLING_ERROR_CODES.SUBSCRIPTION_BUNDLE_ALREADY_CANCELLED, "moved", {
+    subscriptionBundleId
+  });
+}
+function subscriptionContractGone(contractId) {
+  return refusal(CONTRACT_ERROR_CODES.SUBSCRIPTION_CONTRACT_NOT_FOUND, "gone", { contractId });
+}
+
+// src/feature-requires.ts
+function buildFeatureRequiresIndex(features) {
+  const index = /* @__PURE__ */ new Map();
+  for (const feature of features) {
+    const requires = (feature.requires ?? []).filter((key) => key !== feature.featureKey);
+    if (requires.length > 0) index.set(feature.featureKey, requires);
+  }
+  return index;
+}
+function collectUnsatisfiedRequires(selected, index) {
+  const own = new Set(selected);
+  const unsatisfied = /* @__PURE__ */ new Set();
+  for (const featureKey of selected) {
+    for (const required of index.get(featureKey) ?? []) {
+      if (!own.has(required)) unsatisfied.add(required);
+    }
+  }
+  return [...unsatisfied].sort((a, b) => a.localeCompare(b));
+}
+function missingRequiresFor(bundle, coveredFeatures) {
+  const missing = (bundle.requiresFeatures ?? []).filter((key) => !coveredFeatures.has(key));
+  return [...new Set(missing)].sort((a, b) => a.localeCompare(b));
+}
+function resolveBundleAvailability(bundle, coveredFeatures) {
+  if (bundle.features.length > 0 && bundle.features.every((f) => coveredFeatures.has(f))) {
+    return "covered";
+  }
+  if (missingRequiresFor(bundle, coveredFeatures).length > 0) return "missing-requires";
+  return "bookable";
+}
+function coverageExcludingSelf(selfVersionId, planFeatures, selectedBundles) {
+  const covered = new Set(planFeatures);
+  for (const bundle of selectedBundles) {
+    if (bundle.bundleVersionId === selfVersionId) continue;
+    for (const feature of bundle.features) covered.add(feature);
+  }
+  return covered;
+}
+function isBundleRedundant(bundle, planFeatures, selectedBundles) {
+  const covered = coverageExcludingSelf(bundle.bundleVersionId, planFeatures, selectedBundles);
+  return resolveBundleAvailability(bundle, covered) === "covered";
+}
+function compareSelectable(a, b) {
+  const orderA = a.sortOrder ?? Number.MAX_SAFE_INTEGER;
+  const orderB = b.sortOrder ?? Number.MAX_SAFE_INTEGER;
+  if (orderA !== orderB) return orderA - orderB;
+  return a.bundleVersionId.localeCompare(b.bundleVersionId);
+}
+function selectChargeableBundles(planFeatures, selectedBundles) {
+  const kept = [...selectedBundles].sort(compareSelectable);
+  for (; ; ) {
+    const redundantIndex = kept.findIndex(
+      (bundle) => isBundleRedundant(bundle, planFeatures, kept)
+    );
+    if (redundantIndex === -1) return kept;
+    kept.splice(redundantIndex, 1);
+  }
+}
+
+// src/payment-gateway.types.ts
+var PAYMENT_CALLBACK_REJECTED = "PAYMENT_CALLBACK_REJECTED";
+var PaymentCallbackRejectedError = class extends Error {
+  code = PAYMENT_CALLBACK_REJECTED;
+  constructor(reason) {
+    super(`Payment callback rejected: ${reason}`);
+    this.name = "PaymentCallbackRejectedError";
+  }
+};
+function isPaymentCallbackRejectedError(err) {
+  return err instanceof Error && err.code === PAYMENT_CALLBACK_REJECTED;
+}
+
+// src/registration.types.ts
+var PENDING_EMAIL_TTL_HOURS = 72;
+var PENDING_ONBOARDING_TTL_DAYS = 14;
+var PENDING_CHECKOUT_TTL_DAYS = 30;
+var OTP_TTL_MINUTES = 10;
+var PASSWORD_RESET_TTL_MINUTES = 30;
+var OTP_RATE_LIMIT_MAX_SENDS = 3;
+var OTP_RATE_LIMIT_WINDOW_MINUTES = 15;
+var OTP_VERIFY_MAX_ATTEMPTS = 5;
+var REGISTRATION_STEP_BY_STATUS = {
+  PENDING_EMAIL_VERIFICATION: 2,
+  EMAIL_VERIFIED: 3,
+  PLAN_SELECTED: 4,
+  CHECKOUT_STARTED: 4,
+  EXPIRED: 1,
+  DELETED: 1
+};
+var REGISTRATION_RESUME_TTL_MINUTES = 60;
+
+// src/plan-mapping.ts
+function toPlanRow(row) {
+  return {
+    id: row.id,
+    planKey: row.planKey,
+    label: row.label,
+    description: row.description,
+    icon: row.icon,
+    sortOrder: row.sortOrder,
+    createdAt: row.createdAt.toISOString(),
+    updatedAt: row.updatedAt.toISOString(),
+    deletedAt: toIsoOrNull(row.deletedAt)
+  };
+}
+function toPlanVersionRow(row, planKey) {
+  return {
+    id: row.id,
+    version: row.version,
+    baseVersionId: row.baseVersionId,
+    planId: planKey,
+    features: toFeatureKeys(row.features),
+    quotas: toQuotaEffects(row.quotas),
+    monthlyNet: String(row.monthlyNet),
     yearlyNet: String(row.yearlyNet),
     marketed: row.marketed,
     publishedAt: toIsoOrNull(row.publishedAt),
@@ -993,17 +2036,14 @@ function toPlanVersionRow(row, planKey, fields) {
     publishedChanges: Array.isArray(row.publishedChanges) ? row.publishedChanges : null,
     changeNote: row.changeNote,
     nonRegressive: row.nonRegressive,
-    validFrom: fields.validityWindows ? toIsoOrNull(row.validFrom) : null,
-    validUntil: fields.validityWindows ? toIsoOrNull(row.validUntil) : null,
+    validFrom: toIsoOrNull(row.validFrom),
+    validUntil: toIsoOrNull(row.validUntil),
+    endsAt: toIsoOrNull(row.endsAt),
     createdByUserId: row.createdByUserId,
     publishedByUserId: row.publishedByUserId,
     createdAt: row.createdAt.toISOString(),
     updatedAt: row.updatedAt.toISOString()
   };
-  if (fields.endsAt) {
-    mapped.endsAt = toIsoOrNull(row.endsAt);
-  }
-  return mapped;
 }
 function toIsoOrNull(value) {
   return value ? value.toISOString() : null;
@@ -1102,17 +2142,6 @@ function textOrNull(value) {
   return trimmed === "" ? null : trimmed;
 }
 
-// src/closed-value.ts
-function oneOf(allowed, value, source) {
-  const match = allowed.find((entry) => entry === value);
-  if (match === void 0) {
-    throw new Error(
-      `${source.table} row '${source.id}' holds ${source.column} '${value}', which is none of ${allowed.join(", ")}.`
-    );
-  }
-  return match;
-}
-
 // src/subscriber-ledger-mapping.ts
 var ORIGINS = {
   activation: true,
@@ -1127,10 +2156,10 @@ var SOURCES = {
   bundle: true,
   discount: true
 };
-var TABLE = "subscriber_ledger_entries";
+var TABLE2 = "subscriber_ledger_entries";
 var CENT_TOLERANCE = 1e-6;
 function toSubscriberChargeRecord(row) {
-  const where = (column) => ({ table: TABLE, column, id: row.id });
+  const where = (column) => ({ table: TABLE2, column, id: row.id });
   return {
     id: row.id,
     subscriberId: row.subscriberId,
@@ -1150,8 +2179,8 @@ function toSubscriberChargeRecord(row) {
   };
 }
 function subscriberChargeColumns(charge) {
-  const cents = charge.amountNet * 100;
-  if (!Number.isFinite(cents) || Math.abs(cents - Math.round(cents)) > CENT_TOLERANCE) {
+  const cents2 = charge.amountNet * 100;
+  if (!Number.isFinite(cents2) || Math.abs(cents2 - Math.round(cents2)) > CENT_TOLERANCE) {
     throw new Error(
       `A charge of ${charge.amountNet} is not a whole number of cents; round it once where it is derived, before it is written.`
     );
@@ -1294,7 +2323,7 @@ function toIdentityValues(value) {
 // src/subscriber-payment-method-mapping.ts
 var PAYMENT_METHOD_TYPES = ["card", "sepa_debit"];
 var STATUSES = ["ACTIVE", "REPLACED"];
-var TABLE2 = "subscriber_payment_methods";
+var TABLE3 = "subscriber_payment_methods";
 function toSubscriberPaymentMethodRecord(row) {
   return {
     id: row.id,
@@ -1303,7 +2332,7 @@ function toSubscriberPaymentMethodRecord(row) {
     provider: row.provider,
     customerRef: row.customerRef,
     paymentMethodRef: row.paymentMethodRef,
-    type: oneOf(PAYMENT_METHOD_TYPES, row.type, { table: TABLE2, column: "type", id: row.id }),
+    type: oneOf(PAYMENT_METHOD_TYPES, row.type, { table: TABLE3, column: "type", id: row.id }),
     brand: row.brand,
     last4: row.last4,
     expiryMonth: row.expiryMonth,
@@ -1311,7 +2340,7 @@ function toSubscriberPaymentMethodRecord(row) {
     country: row.country,
     bankCode: row.bankCode,
     mandateReference: row.mandateReference,
-    status: oneOf(STATUSES, row.status, { table: TABLE2, column: "status", id: row.id }),
+    status: oneOf(STATUSES, row.status, { table: TABLE3, column: "status", id: row.id }),
     confirmedAt: row.confirmedAt,
     replacedAt: row.replacedAt,
     createdAt: row.createdAt
@@ -1492,6 +2521,52 @@ var ACTIVE_SUBSCRIPTION_CONTRACT_STATUSES = [
   "scheduled"
 ];
 
+// src/custom-limits.ts
+var CUSTOM_LIMITS_KEYS = ["quotas", "features"];
+var NOT_AN_OBJECT = "(the value is not an object)";
+function readCustomLimits(value) {
+  if (value === null || value === void 0) return { limits: null, unread: [] };
+  if (typeof value !== "object" || Array.isArray(value)) {
+    return { limits: null, unread: [NOT_AN_OBJECT] };
+  }
+  const limits = {};
+  const unread = [];
+  for (const [key, entry] of Object.entries(value)) {
+    if (key === "quotas" && isRecord(entry)) {
+      limits.quotas = {};
+      for (const [quota, amount] of Object.entries(entry)) {
+        const value2 = readQuotaValue(amount);
+        if (value2 === null) unread.push(`quotas.${quota}`);
+        else limits.quotas[quota] = value2;
+      }
+    } else if (key === "features" && isFeatureList(entry)) {
+      limits.features = [...entry];
+    } else {
+      unread.push(key);
+    }
+  }
+  return { limits, unread };
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isFeatureList(value) {
+  return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}
+function customLimitsReader(report) {
+  const reported = /* @__PURE__ */ new Set();
+  return (subscriptionId, stored) => {
+    const { limits, unread } = readCustomLimits(stored);
+    if (unread.length > 0 && !reported.has(subscriptionId)) {
+      reported.add(subscriptionId);
+      report(
+        `Subscription ${subscriptionId}: customLimits carries ${unread.join(", ")}, which the platform does not read, so these limits are not applied. It reads { quotas: { <quotaKey>: number }, features: string[] } (CustomLimits in @saasicat/core).`
+      );
+    }
+    return limits;
+  };
+}
+
 // src/version-editability.ts
 function isVersionEditable(v, now = /* @__PURE__ */ new Date()) {
   if (v.publishedAt === null) {
@@ -1530,217 +2605,6 @@ function keepOneRecommended(plans, inRequestedLocale) {
   return winner;
 }
 
-// src/error-messages.ts
-var ERROR_MESSAGES_EN = {
-  // ── setup ──
-  SETUP_DISABLED: "{envVar} is not set \u2014 setup is disabled.",
-  INVALID_SETUP_TOKEN: "The setup token is not valid.",
-  SETUP_ALREADY_DONE: "Setup has already been completed.",
-  INVALID_EMAIL: "That is not a valid email address.",
-  EMAIL_EXISTS: "An account with this email address already exists.",
-  // ── auth ──
-  NOT_AUTHENTICATED: "Not authenticated",
-  NO_TENANT_ASSIGNED: "No tenant assigned",
-  TENANT_CONTEXT_MISSING: "No tenant ID found on the request",
-  TENANT_ADMIN_REQUIRED: "This action requires the TENANT_ADMIN role.",
-  BILLING_PERMISSION_REQUIRED: "This part of the billing area requires the billing permission.",
-  SUPER_ADMIN_REQUIRED: "Only the SUPER_ADMIN role is allowed",
-  MFA_NOT_SET_UP: "Run the MFA setup via the CLI first.",
-  MFA_REQUIRED: "TOTP code required in the X-Mfa-Code header.",
-  MFA_FAILED: "Invalid TOTP code.",
-  AUTH_GUARDS_NOT_CONFIGURED: "TenantBillingModule.forRoot.authGuards is not configured.",
-  // ── catalog ──
-  PLAN_HAS_DRAFTS: "Plan '{planKey}' still has {draftCount} open draft version(s). Discard them first (DELETE /admin/catalog/plan-versions/:id) or publish them.",
-  PLAN_HAS_PUBLISHED_VERSIONS: "Plan '{planKey}' cannot be {operation} \u2014 it has {publishedCount} published version(s) ({liveCount} live, {supersededCount} superseded). Existing subscriptions reference those versions (contract protection P1), so the plan record must be preserved.",
-  PLAN_HARD_DELETE_NOT_IMPLEMENTED: "Hard delete is not implemented in the current repository. Implement PlanRepository.hardDelete.",
-  PLAN_VERSION_ALREADY_PUBLISHED: "PlanVersion '{versionId}' is already published and cannot be discarded.",
-  PLAN_VERSION_NOT_EDITABLE: "PlanVersion '{versionId}' is not editable. Only drafts and published versions are editable that are latest-in-chain, bind no subscription yet, and whose validFrom lies in the future.",
-  PLAN_VERSION_REGRESSION: "This plan version is regressive (feature removed / quota lowered / price raised). Publishing requires an explicit `forceRegressive: true` (UI confirmation dialog with MFA).",
-  PLAN_VERSION_ZERO_PRICE: "A plan version cannot be published with a price of 0.00 (guard against seed placeholder). For deliberately free special contracts, set allowZeroPrice.",
-  PLAN_VERSION_DISCARD_NOT_IMPLEMENTED: "Discard is not implemented in the current repository. Implement PlanRepository.deletePlanVersionDraft.",
-  PLAN_VERSION_NOT_PUBLISHED: "PlanVersion '{versionId}' is not published and cannot be terminated.",
-  PLAN_VERSION_SUPERSEDED: "PlanVersion '{versionId}' has already been superseded by a newer version and cannot be terminated.",
-  PLAN_VERSION_VALID_FROM_REQUIRED: "validFrom must be set when publishing (on the draft or the publish call)..",
-  PLAN_VERSION_VALID_FROM_INVALID: "validFrom '{validFrom}' is not a valid date",
-  PLAN_VERSION_VALID_FROM_NOT_AFTER_PREVIOUS: "validFrom ({validFrom}) must be strictly after the validFrom of the previous version ({previousValidFrom}).",
-  PLAN_VERSION_VALID_FROM_NOT_GAPLESS: "The predecessor has validUntil={previousValidUntil} \u2014 the successor must start seamlessly on the next day ({requiredValidFrom}). Received: {received}.",
-  PLAN_VERSION_VALID_UNTIL_INVALID: "validUntil '{validUntil}' is not a valid date",
-  PLAN_VERSION_VALID_UNTIL_BEFORE_FROM: "validUntil ({validUntil}) must be strictly after validFrom ({validFrom}).",
-  PLAN_TERMINATE_INVALID_DATE: "endsAt is not a valid date.",
-  PLAN_TERMINATE_DATE_NOT_FUTURE: "endsAt ({endsAt}) must lie strictly in the future.",
-  PLAN_TERMINATE_NOT_IMPLEMENTED: "Terminate is not implemented in the current repository. Implement PlanRepository.terminate.",
-  BUNDLE_VERSION_ALREADY_PUBLISHED: "BundleVersion '{versionId}' is already published and cannot be discarded.",
-  BUNDLE_VERSION_NOT_EDITABLE: "BundleVersion '{versionId}' is not editable. Only drafts and published versions are editable that are latest-in-chain, bind no subscription yet, and whose validFrom lies in the future.",
-  BUNDLE_VERSION_NOT_PUBLISHED: "BundleVersion '{bundleVersionId}' is not published and cannot be booked.",
-  BUNDLE_VERSION_SUPERSEDED: "BundleVersion '{bundleVersionId}' has been superseded by a newer version.",
-  BUNDLE_VERSION_REGRESSION: "This bundle version is regressive (feature removed / quota lowered / price raised). Publishing requires an explicit `forceRegressive: true` (UI confirmation dialog with MFA).",
-  BUNDLE_VERSION_ZERO_PRICE: "A bundle version cannot be published with an explicit price of 0.00 (guard against seed placeholders). For free bundles leave it null, or set allowZeroPrice.",
-  BUNDLE_VERSION_NO_PRICE: "This bundle version cannot be published without a price: neither a base price nor any plan override resolves one.",
-  BUNDLE_VERSION_NOT_PRICED_FOR_PLAN: "This bundle is offered to plan '{planKey}', which is sold {billingCycle}, and no {billingCycle} price resolves for it \u2014 neither a base price nor a plan override.",
-  BUNDLE_VERSION_DISCARD_NOT_IMPLEMENTED: "Discard is not implemented in the current repository. Implement BundleRepository.deleteDraft.",
-  BUNDLE_VERSION_VALID_FROM_REQUIRED: "Published bundle versions must keep a validFrom. Set a new future date, or edit the draft before publishing.",
-  BUNDLE_VERSION_VALID_FROM_INVALID: "validFrom '{validFrom}' is not a valid date",
-  BUNDLE_VERSION_VALID_FROM_NOT_AFTER_PREVIOUS: "validFrom ({validFrom}) must be strictly after the validFrom of the previous version ({previousValidFrom}).",
-  BUNDLE_VERSION_VALID_FROM_NOT_GAPLESS: "The predecessor has validUntil={previousValidUntil} \u2014 the successor must start seamlessly on the next day ({requiredValidFrom}). Received: {received}.",
-  BUNDLE_VERSION_VALID_FROM_NOT_FUTURE: "validFrom ({validFrom}) must, for a published-but-future bundle version, still lie in the future.",
-  BUNDLE_VERSION_VALID_UNTIL_INVALID: "validUntil '{validUntil}' is not a valid date",
-  BUNDLE_VERSION_VALID_UNTIL_BEFORE_FROM: "validUntil ({validUntil}) must be strictly after validFrom ({validFrom}).",
-  STRICT_MODE_VIOLATIONS: "The strict-mode check found drift against the discovery snapshot.",
-  PLAN_NOT_FOUND: "Plan '{planId}' not found",
-  PLAN_VERSION_NOT_FOUND: "PlanVersion '{versionId}' not found",
-  BUNDLE_NOT_FOUND: "Bundle '{bundleId}' not found",
-  BUNDLE_VERSION_NOT_FOUND: "BundleVersion '{bundleVersionId}' not found",
-  FEATURE_NOT_FOUND: "Feature '{featureKey}' not found",
-  QUOTA_NOT_FOUND: "Quota '{quotaKey}' not found",
-  PROMOTION_NOT_FOUND: "Promotion '{promotionId}' not found",
-  PROMOTION_VALUE_INVALID: "The value of a '{type}' promotion is not one its type takes: a percentage above 0 and at most 100, an amount above 0, an intro price of at least 0 for a whole number of months, or a whole number of free months.",
-  MARKETING_PROJECTION_NOT_FOUND: "MarketingProjection '{projectionId}' not found",
-  PLAN_ALREADY_EXISTS: "Plan '{planKey}' already exists",
-  BUNDLE_ALREADY_EXISTS: "Bundle '{bundleKey}' already exists",
-  MARKETING_PROJECTION_ALREADY_EXISTS: "Marketing projection for {targetType}/{targetVersionId}/{locale} already exists \u2014 use PATCH to edit it",
-  PLAN_DRAFT_ALREADY_EXISTS: "Plan '{planKey}' already has a draft version v{draftVersion}; publish or discard it first",
-  BUNDLE_DRAFT_ALREADY_EXISTS: "Bundle '{bundleKey}' already has a draft version v{draftVersion}; publish or discard it first",
-  QUOTA_NOT_IN_DISCOVERY_SNAPSHOT: "Quota '{quotaKey}' is not in the discovery snapshot \u2014 a quota that is not declared in code cannot be approved",
-  DISCOVERY_STATUS_TRANSITION_INVALID: "Transition '{from}' \u2192 '{to}' is not allowed",
-  DISCOVERY_NOT_INITIALIZED: "Approval requires a discovery snapshot \u2014 discovery is not initialised (#25)",
-  // ── catalogue import ──
-  PLAN_CATALOG_UNREADABLE: "That file is not a plan catalog \u2014 it could not be read as one. Check that it is the YAML your app declares its plans in.",
-  PLAN_CATALOG_INVALID: "The plan catalog was read, and then rejected: {message}",
-  // ── billing ──
-  BUNDLE_ALREADY_SUBSCRIBED: "Subscription '{subscriptionId}' has already actively booked this bundle.",
-  BUNDLE_INCOMPATIBLE_WITH_PLAN: "BundleVersion '{bundleVersionId}' is not compatible with plan '{planKey}'. Allowed: [{allowedPlanKeys}].",
-  BUNDLE_NOT_SELF_SERVICE: "Bundle '{bundleKey}' is only activated via a special contract. Please contact the contract manager.",
-  BUNDLE_CYCLE_EXCEEDS_PLAN: "A yearly bundle cannot run beside a monthly plan: it would still be committed on every day the plan could end.",
-  BUNDLE_NOT_PRICED_FOR_THIS_PLAN: "This bundle has no {billingCycle} price for the {planKey} plan, so it cannot be booked from here.",
-  SUBSCRIPTION_BUNDLE_ALREADY_CANCELLED: "SubscriptionBundle '{subscriptionBundleId}' is already cancelled.",
-  SUBSCRIPTION_BUNDLE_NOT_CANCELLED: "SubscriptionBundle '{subscriptionBundleId}' is not cancelled.",
-  SUBSCRIPTION_BUNDLE_CANCELLATION_EFFECTIVE: "Cancellation already in effect \u2014 book the bundle again.",
-  SUBSCRIPTION_NOT_FOUND: "No subscription for tenant {tenantId}",
-  SUBSCRIPTION_TENANT_MISMATCH: "Subscription does not belong to the tenant",
-  SUBSCRIPTION_BUNDLE_NOT_FOUND: "SubscriptionBundle '{subscriptionBundleId}' not found",
-  TENANT_NOT_FOUND: "Tenant {slug} not found",
-  NO_ACTIVE_PLAN_VERSION: "No plan version for {planId} active as of {asOf} \u2014 neither the validFrom window is satisfied nor is a latest-live version available.",
-  PLAN_NOT_IN_CATALOG: 'Plan "{planKey}" is not in the catalog',
-  PLAN_NOT_SELF_SERVICE: "{planName} is only activated via a special contract. Please contact the contract manager.",
-  PLAN_NOT_SOLD_IN_CYCLE: "{planName} has no price for this billing rhythm and cannot be booked in it.",
-  PLAN_CHANGE_BLOCKED: "Plan change during onboarding is blocked.",
-  SUBSCRIPTION_CHANGED: "This subscription changed while the request was being decided. Reload it.",
-  NO_SUBSCRIPTION: "This tenant has no subscription to cancel.",
-  CANCELLATION_TERMS_CHANGED: "The effective date changed since it was shown. Confirm the new one.",
-  SUBSCRIPTION_ENDED: "This subscription has ended. Its plan can no longer be changed.",
-  PLAN_LOCKED: "Active {planName} special contract \u2014 please contact the contract manager to change plans.",
-  QUOTA_OVER_TARGET: "Current usage {used} exceeds the target limit {targetMax} ({quotaKey}) in the {planName} plan. Please reduce usage first.",
-  FEATURE_LOST: "Switching means losing access to one feature. Existing data is retained and never deleted \u2014 upgrading again unlocks it.",
-  FEATURES_LOST: "Switching means losing access to {count} features. Existing data is retained and never deleted \u2014 upgrading again unlocks it.",
-  NO_CHANGE: "Target plan and billing cycle already match the current state.",
-  CANCELLATION_LOCKS_THE_CYCLE: "This subscription is cancelled, so its billing cycle cannot change. The plan can \u2014 keep the current cycle to change it today.",
-  CYCLE_SHORTENS_AT_TERM_END: "A monthly {planName} cannot start inside the yearly term you are in. The upgrade takes effect when that term ends; to have it today, keep the yearly cycle.",
-  BUNDLE_BOOKING_OUTLASTS_TARGET_CYCLE: "A yearly bundle is booked until {until}. A monthly plan cannot carry it \u2014 cancel the bundle first, or keep the yearly cycle.",
-  REDUNDANT_FEATURES: "The plan or another booked bundle already includes {count} of the features in this bundle \u2014 booking it pays for them twice.",
-  MINIMUM_TERM_BINDS: "The minimum term extends beyond the end of the period \u2014 the cancellation only takes effect when the minimum term ends.",
-  BUNDLE_FEATURE_DEPENDENCY_UNSATISFIED: "The bundle requires [{features}] \u2014 present neither in the plan nor in the active bundles.",
-  NO_PENDING_PLAN_VERSION: "There is no pending plan version awaiting confirmation.",
-  ONBOARDING_CREATE_FAILED: "The account could not be created. Please try again.",
-  BUNDLE_PREVIEW_ARGUMENT_AMBIGUOUS: "Exactly one of bundleVersionId (add preview) or subscriptionBundleId (cancel preview) must be given.",
-  SUBSCRIPTION_PK_MISSING: "The adapter returned a subscription usage record without an id. Pass the subscription primary key through (see SubscriptionUsageRecord.id).",
-  LIMIT_EXCEEDED: "The limit for {dimension} has been reached: {used} of {max}.",
-  QUOTA_DIMENSION_UNKNOWN: 'Unknown quota dimension "{dimension}".',
-  // ── promo ──
-  PROMO_CODE_NOT_FOUND: "Code not found",
-  PROMO_CODE_ALREADY_EXISTS: "The code already exists.",
-  PROMO_CODE_HAS_REDEMPTIONS: "The code already has redemptions, or checkouts holding one \u2014 it cannot be soft-deleted. Pause it instead.",
-  PROMO_CODE_NOT_REDEEMABLE: "Code cannot be redeemed: {reason}",
-  PROMO_CODE_FORMAT_INVALID: 'The code may only contain upper-case letters, digits, "-" and "_" (4\u201332 characters).',
-  PROMO_PERCENT_OUT_OF_RANGE: "The percentage must be between 0 and 100.",
-  PROMO_AMOUNT_NOT_POSITIVE: "The amount must be positive.",
-  PROMO_ONE_OFF_WITH_DURATION: "A one-off discount must not set a duration.",
-  PROMO_DURATION_INVALID: "Invalid duration (at most 24 months or billing periods).",
-  PROMO_VALIDITY_WINDOW_INVALID: "Invalid validity window.",
-  PROMO_PLAN_NOT_DISCOUNTABLE: "{plan}-Plan cannot be discounted.",
-  PROMO_MIN_AMOUNT_NOT_POSITIVE: "The minimum plan gross amount must be positive.",
-  PROMO_WOULD_PRODUCE_ZERO_INVOICE: "For absolute amounts the discount must stay below the lowest applicable plan price, or allowZeroInvoice must be enabled.",
-  PROMO_MAX_REDEMPTIONS_LOWERED: "maxRedemptions cannot be lowered.",
-  // ── contract ──
-  CHECKOUT_OFFER_LINE_ITEMS_REQUIRED: "A checkout offer can yield only one contract, and only once its line items are frozen.",
-  CHECKOUT_OFFER_PLAN_LINE_ITEM_REQUIRED: "A checkout offer requires a frozen plan line item.",
-  CHECKOUT_OFFER_BUNDLE_LINE_ITEMS_REQUIRED: "Every selected bundle version requires a frozen bundle line item.",
-  CHECKOUT_OFFER_BUNDLE_VERSION_NOT_BOOKABLE: "At least one bundle version from the checkout offer is no longer bookable.",
-  CHECKOUT_OFFER_FEATURE_DEPENDENCY_UNSATISFIED: "The selected plan does not cover all feature dependencies: [{missingRequires}] are missing from the plan + selected bundles.",
-  CHECKOUT_OFFER_PLAN_NOT_OFFERED: "Plan '{planKey}' is not offered with a {billingCycle} price at the moment.",
-  CHECKOUT_OFFER_BUNDLE_NOT_OFFERED: "Bundle version '{bundleVersionId}' cannot be added to this offer ({reason}).",
-  CHECKOUT_OFFER_PROMO_CODE_NOT_ACCEPTED: "The promo code cannot be applied to this offer ({reason}).",
-  CHECKOUT_OFFER_PRICE_NOT_CURRENT: "The prices of checkout offer '{offerId}' no longer match the catalogue; create a new offer.",
-  SUBSCRIPTION_CONTRACT_LINE_ITEMS_REQUIRED: "A subscription contract requires at least one line item.",
-  SUBSCRIPTION_CONTRACT_PLAN_LINE_ITEM_REQUIRED: "A subscription contract requires exactly one plan base item.",
-  SUBSCRIPTION_CONTRACT_INVALID_DATE: "{field} must be a valid date.",
-  SUBSCRIPTION_CONTRACT_INVALID_WINDOW: "effectiveUntil must be after effectiveFrom.",
-  SUBSCRIPTION_CONTRACT_LINE_ITEM_TAX_MISMATCH: "A line item's taxAmount must be exactly priceGross minus priceNet.",
-  SUBSCRIPTION_CONTRACT_TAX_RATE_NOT_PERCENT: "A subscription contract states a tax rate of {taxRate} at {field}, which is not a percentage: a rate lies from 0 to 100, and a value between 0 and 1 is refused as a fraction.",
-  SUBSCRIPTION_CONTRACT_TERMINATION_BEFORE_START: "effectiveUntil must be after the effectiveFrom of the contract.",
-  SUBSCRIPTION_CONTRACT_LINE_ITEM_CURRENCY_MISMATCH: "A line item must be booked in the currency its contract was priced in.",
-  SUBSCRIPTION_CONTRACT_LINES_DO_NOT_ADD_UP: "The line items of a subscription contract add up to {lines} for {field}, but the contract states {stated}.",
-  SUBSCRIPTION_CONTRACT_DISCOUNT_NEGATIVE: "A subscription contract states a discount of {amount} at {field}; a discount takes money off and is never negative.",
-  CHECKOUT_OFFER_NOT_FOUND: "CheckoutOffer '{offerId}' not found",
-  CHECKOUT_OFFER_EXPIRED: "Checkout offer '{offerId}' has expired and cannot be {action}",
-  CHECKOUT_OFFER_ALREADY_CONSUMED: "Checkout offer '{offerId}' has already been consumed and cannot be {action}",
-  CHECKOUT_OFFER_NOT_CONSUMED: "CheckoutOffer '{offerId}' must be consumed before the contract is created",
-  CHECKOUT_OFFER_CHANGED: "Checkout offer '{offerId}' changed while it was being concluded. Load it again.",
-  SUBSCRIPTION_CONTRACT_NOT_FOUND: "SubscriptionContract '{contractId}' not found",
-  NO_ACTIVE_SUBSCRIPTION_CONTRACT: "No active subscription contract for tenant {tenantId}",
-  SUBSCRIPTION_CONTRACT_ALREADY_CLOSED: "SubscriptionContract '{contractId}' is already closed",
-  // ── subscriber ──
-  SUBSCRIBER_REQUIRED: "Tenant '{tenantId}' has no subscriber. Nothing is agreed or charged without the party to it: create the tenant's subscriber first.",
-  SUBSCRIBER_ALREADY_EXISTS: "Tenant '{tenantId}' already has a subscriber.",
-  SUBSCRIBER_NOT_FOUND: "Subscriber '{subscriberId}' not found",
-  SUBSCRIBER_LEGAL_NAME_REQUIRED: "A subscriber needs its legal name.",
-  SUBSCRIBER_DETAIL_INVALID: "The subscriber's {field} is not valid.",
-  SUBSCRIBER_IDENTITY_NOT_A_CONTACT: "{field} is part of the subscriber's legal identity and changes only as a correction, with a reason.",
-  SUBSCRIBER_CORRECTION_REASON_REQUIRED: "A correction of the legal identity needs a reason.",
-  SUBSCRIBER_CORRECTION_ACTOR_REQUIRED: "A correction of the legal identity has to say who makes it.",
-  SUBSCRIBER_CORRECTION_CHANGES_NOTHING: "The correction changes nothing: every value it names is already recorded.",
-  SUBSCRIBER_TAKEOVER_IS_A_TRANSFER: "Another legal entity taking over a subscriber is a transfer, not a correction, and cannot be recorded as an edit.",
-  // ── registration ──
-  PENDING_REGISTRATION_NOT_FOUND: "This registration could not be found. It may have already been completed or discarded.",
-  PENDING_REGISTRATION_EXPIRED: "This registration has expired. Please start again.",
-  INVALID_REGISTRATION_STATE: "This step is not available at the current stage of the registration.",
-  OTP_INVALID: "That code is not correct. Please check it and try again.",
-  OTP_EXPIRED: "That code has expired. Please request a new one.",
-  OTP_LOCKED: "Too many incorrect attempts. Please request a new code.",
-  RATE_LIMITED: "Too many attempts. Please try again in {retryAfterSeconds} seconds.",
-  RESUME_TOKEN_INVALID: "This resume link is no longer valid. Please request a new one.",
-  RESUME_NOT_CONFIGURED: "Resuming a registration is not available.",
-  CONFIGURATOR_NOT_CONFIGURED: "The configurator is not available.",
-  CONFIG_NOT_SAVED: "The configuration could not be saved.",
-  PLAN_NOT_AVAILABLE: "This plan is not available.",
-  PLAN_NOT_SELECTED: "Please select a plan first.",
-  MODEL_NOT_AVAILABLE: "This option is not available.",
-  // ── payments ──
-  PAYMENTS_NOT_CONFIGURED: "Payment methods cannot be set up here yet.",
-  PAYMENT_GATEWAY_ACCOUNT_UNKNOWN: "No payment gateway account is configured under '{account}'.",
-  PAYMENT_CALLBACK_REJECTED: "The payment callback could not be verified.",
-  PAYMENT_RETURN_URL_NOT_ALLOWED: "The {field} leads to a site this installation does not return to.",
-  PAYMENT_GATEWAY_FAILED: "The payment provider did not answer as expected. Please try again in a few minutes.",
-  // ── entitlement (code lives in upsell.types.ts) ──
-  [FEATURE_NOT_LICENSED]: "Feature {featureKeys} is not included in the current plan.",
-  // ── settings ──
-  SETTINGS_CHANGE_NOT_FOUND: "No recorded settings change has this id."
-};
-function formatErrorMessage(template, params = {}) {
-  return template.replace(/\{(\w+)\}/g, (match, name) => {
-    const value = params[name];
-    return value === void 0 || value === null ? match : String(value);
-  });
-}
-function resolveErrorMessage(body, overrides = {}, defaults = ERROR_MESSAGES_EN) {
-  const code = typeof body.code === "string" ? body.code : void 0;
-  const template = (code && (overrides[code] ?? defaults[code])) ?? void 0;
-  if (!template) {
-    return typeof body.message === "string" ? body.message : code ?? "";
-  }
-  const { params, ...rest } = body;
-  return formatErrorMessage(template, { ...rest, ...params });
-}
-
 // src/error-messages-de.ts
 var ERROR_MESSAGES_DE = {
   // ── setup ──
@@ -1764,7 +2628,7 @@ var ERROR_MESSAGES_DE = {
   PLAN_HAS_DRAFTS: "Plan '{planKey}' hat noch {draftCount} offene Entwurfsversion(en). Verwirf sie zuerst (DELETE /admin/catalog/plan-versions/:id) oder ver\xF6ffentliche sie.",
   PLAN_HAS_PUBLISHED_VERSIONS: "Plan '{planKey}' kann nicht {operation} werden \u2014 er hat {publishedCount} ver\xF6ffentlichte Version(en) ({liveCount} live, {supersededCount} abgel\xF6st). Bestehende Abonnements verweisen auf diese Versionen (Vertragsschutz P1), deshalb muss der Plan-Datensatz erhalten bleiben.",
   PLAN_HARD_DELETE_NOT_IMPLEMENTED: "Hard Delete ist im aktuellen Repository nicht implementiert. Implementiere PlanRepository.hardDelete.",
-  PLAN_VERSION_ALREADY_PUBLISHED: "PlanVersion '{versionId}' ist bereits ver\xF6ffentlicht und kann nicht verworfen werden.",
+  PLAN_VERSION_ALREADY_PUBLISHED: "PlanVersion '{versionId}' ist bereits ver\xF6ffentlicht und wird weder erneut ver\xF6ffentlicht noch verworfen.",
   PLAN_VERSION_NOT_EDITABLE: "PlanVersion '{versionId}' ist nicht bearbeitbar. Bearbeitbar sind nur Entw\xFCrfe sowie ver\xF6ffentlichte Versionen, die letzte in der Kette sind, noch kein Abonnement binden und deren validFrom in der Zukunft liegt.",
   PLAN_VERSION_REGRESSION: "Diese Planversion ist regressiv (Feature entfernt / Quota gesenkt / Preis erh\xF6ht). Das Ver\xF6ffentlichen erfordert ein ausdr\xFCckliches `forceRegressive: true` (Best\xE4tigungsdialog in der UI mit MFA).",
   PLAN_VERSION_ZERO_PRICE: "Eine Planversion l\xE4sst sich nicht mit einem Preis von 0,00 ver\xF6ffentlichen (Schutz vor Seed-Platzhaltern). F\xFCr bewusst kostenlose Sondervertr\xE4ge setze allowZeroPrice.",
@@ -1772,29 +2636,34 @@ var ERROR_MESSAGES_DE = {
   PLAN_VERSION_NOT_PUBLISHED: "Die PlanVersion '{versionId}' ist nicht ver\xF6ffentlicht und kann nicht beendet werden.",
   PLAN_VERSION_SUPERSEDED: "Die PlanVersion '{versionId}' wurde bereits von einer Nachfolgeversion abgel\xF6st und kann nicht beendet werden.",
   PLAN_VERSION_VALID_FROM_REQUIRED: "validFrom muss beim Ver\xF6ffentlichen gesetzt sein (am Entwurf oder im Publish-Aufruf)..",
-  PLAN_VERSION_VALID_FROM_INVALID: "validFrom '{validFrom}' ist kein g\xFCltiges Datum",
+  PLAN_VERSION_VALID_FROM_INVALID: "validFrom '{validFrom}' ist kein Tag (JJJJ-MM-TT)",
   PLAN_VERSION_VALID_FROM_NOT_AFTER_PREVIOUS: "validFrom ({validFrom}) muss strikt nach dem validFrom der Vorg\xE4ngerversion ({previousValidFrom}) liegen.",
   PLAN_VERSION_VALID_FROM_NOT_GAPLESS: "Der Vorg\xE4nger hat validUntil={previousValidUntil} \u2014 der Nachfolger muss l\xFCckenlos am Folgetag ({requiredValidFrom}) beginnen. Erhalten: {received}.",
-  PLAN_VERSION_VALID_UNTIL_INVALID: "validUntil '{validUntil}' ist kein g\xFCltiges Datum",
+  PLAN_VERSION_VALID_UNTIL_INVALID: "validUntil '{validUntil}' ist kein Tag (JJJJ-MM-TT)",
   PLAN_VERSION_VALID_UNTIL_BEFORE_FROM: "validUntil ({validUntil}) muss strikt nach validFrom ({validFrom}) liegen.",
   PLAN_TERMINATE_INVALID_DATE: "endsAt ist kein g\xFCltiges Datum.",
   PLAN_TERMINATE_DATE_NOT_FUTURE: "endsAt ({endsAt}) muss strikt in der Zukunft liegen.",
   PLAN_TERMINATE_NOT_IMPLEMENTED: "Das Beenden ist im aktuellen Repository nicht implementiert. Implementiere PlanRepository.terminate.",
-  BUNDLE_VERSION_ALREADY_PUBLISHED: "BundleVersion '{versionId}' ist bereits ver\xF6ffentlicht und kann nicht verworfen werden.",
+  PLAN_TERMINATE_BEFORE_RETIREMENT_MOVES: "Abonnements ziehen noch auf Version {version} von {planKey} um. Sie kann fr\xFChestens am {date} enden.",
+  PLAN_TERMINATE_WHILE_MOVES_OVERDUE: "{count} Abonnements sind \xFCber ihr Datum und ziehen noch auf Version {version} von {planKey} um. Sie kann erst enden, wenn sie umgezogen sind.",
+  PLAN_TERMINATE_WHILE_NOTICES_UNDELIVERED: "{count} Abonnements wissen noch nicht, dass sie auf Version {version} von {planKey} umziehen. Sie kann erst enden, wenn sie es erfahren haben.",
+  BUNDLE_VERSION_ALREADY_PUBLISHED: "BundleVersion '{versionId}' ist bereits ver\xF6ffentlicht und wird weder erneut ver\xF6ffentlicht noch verworfen.",
   BUNDLE_VERSION_NOT_EDITABLE: "BundleVersion '{versionId}' ist nicht bearbeitbar. Bearbeitbar sind nur Entw\xFCrfe sowie ver\xF6ffentlichte Versionen, die letzte in der Kette sind, noch kein Abonnement binden und deren validFrom in der Zukunft liegt.",
   BUNDLE_VERSION_NOT_PUBLISHED: "BundleVersion '{bundleVersionId}' ist nicht ver\xF6ffentlicht und l\xE4sst sich nicht buchen.",
   BUNDLE_VERSION_SUPERSEDED: "BundleVersion '{bundleVersionId}' wurde durch eine neuere Version abgel\xF6st.",
+  BUNDLE_VERSION_NOT_YET_ON_SALE: "BundleVersion '{bundleVersionId}' ist ab {validFrom} im Verkauf und kann vorher nicht gebucht werden.",
+  BUNDLE_DELETED: "Bundle '{bundleKey}' wurde aus dem Katalog gel\xF6scht und l\xE4sst sich nicht buchen.",
   BUNDLE_VERSION_REGRESSION: "Diese Bundle-Version ist regressiv (Feature entfernt / Quota gesenkt / Preis erh\xF6ht). Das Ver\xF6ffentlichen erfordert ein ausdr\xFCckliches `forceRegressive: true` (Best\xE4tigungsdialog in der UI mit MFA).",
   BUNDLE_VERSION_ZERO_PRICE: "Eine Bundle-Version l\xE4sst sich nicht mit einem ausdr\xFCcklichen Preis von 0,00 ver\xF6ffentlichen (Schutz vor Seed-Platzhaltern). Kostenlose Bundles l\xE4sst du auf null, oder du setzt allowZeroPrice.",
   BUNDLE_VERSION_NO_PRICE: "Diese Bundle-Version kann ohne Preis nicht ver\xF6ffentlicht werden: weder ein Grundpreis noch eine Plan-\xDCberschreibung ergibt einen.",
   BUNDLE_VERSION_NOT_PRICED_FOR_PLAN: "Dieses Bundle wird dem Plan '{planKey}' angeboten, der {billingCycle} verkauft wird, und daf\xFCr ergibt sich kein {billingCycle} Preis \u2014 weder als Grundpreis noch als Plan-\xDCberschreibung.",
   BUNDLE_VERSION_DISCARD_NOT_IMPLEMENTED: "Das Verwerfen ist im aktuellen Repository nicht implementiert. Implementiere BundleRepository.deleteDraft.",
   BUNDLE_VERSION_VALID_FROM_REQUIRED: "Ver\xF6ffentlichte Bundle-Versionen m\xFCssen ein validFrom behalten. Setze ein neues Datum in der Zukunft, oder bearbeite den Entwurf vor dem Ver\xF6ffentlichen.",
-  BUNDLE_VERSION_VALID_FROM_INVALID: "validFrom '{validFrom}' ist kein g\xFCltiges Datum",
+  BUNDLE_VERSION_VALID_FROM_INVALID: "validFrom '{validFrom}' ist kein Tag (JJJJ-MM-TT)",
   BUNDLE_VERSION_VALID_FROM_NOT_AFTER_PREVIOUS: "validFrom ({validFrom}) muss strikt nach dem validFrom der Vorg\xE4ngerversion ({previousValidFrom}) liegen.",
   BUNDLE_VERSION_VALID_FROM_NOT_GAPLESS: "Der Vorg\xE4nger hat validUntil={previousValidUntil} \u2014 der Nachfolger muss l\xFCckenlos am Folgetag ({requiredValidFrom}) beginnen. Erhalten: {received}.",
   BUNDLE_VERSION_VALID_FROM_NOT_FUTURE: "validFrom ({validFrom}) muss bei einer ver\xF6ffentlichten, aber zuk\xFCnftigen Bundle-Version weiterhin in der Zukunft liegen.",
-  BUNDLE_VERSION_VALID_UNTIL_INVALID: "validUntil '{validUntil}' ist kein g\xFCltiges Datum",
+  BUNDLE_VERSION_VALID_UNTIL_INVALID: "validUntil '{validUntil}' ist kein Tag (JJJJ-MM-TT)",
   BUNDLE_VERSION_VALID_UNTIL_BEFORE_FROM: "validUntil ({validUntil}) muss strikt nach validFrom ({validFrom}) liegen.",
   STRICT_MODE_VIOLATIONS: "Die Strict-Mode-Pr\xFCfung hat eine Abweichung gegen\xFCber dem Discovery-Snapshot gefunden.",
   PLAN_NOT_FOUND: "Plan '{planId}' nicht gefunden",
@@ -1819,10 +2688,12 @@ var ERROR_MESSAGES_DE = {
   PLAN_CATALOG_INVALID: "Der Plankatalog wurde gelesen und dann abgelehnt: {message}",
   // ── billing ──
   BUNDLE_ALREADY_SUBSCRIBED: "Abonnement '{subscriptionId}' hat dieses Bundle bereits aktiv gebucht.",
-  BUNDLE_INCOMPATIBLE_WITH_PLAN: "BundleVersion '{bundleVersionId}' passt nicht zum Plan '{planKey}'. Erlaubt: [{allowedPlanKeys}].",
+  BUNDLE_INCOMPATIBLE_WITH_PLAN: "Dieses Bundle kann im Plan {planKey} nicht gebucht werden. Buchbar ist es in: {allowedPlanKeys}.",
   BUNDLE_NOT_SELF_SERVICE: "Bundle '{bundleKey}' wird nur \xFCber einen Sondervertrag freigeschaltet. Bitte wende dich an die Vertragsverwaltung.",
   BUNDLE_CYCLE_EXCEEDS_PLAN: "Ein j\xE4hrlich abgerechnetes Bundle passt nicht zu einem monatlich abgerechneten Plan: es w\xE4re an jedem Tag gebunden, an dem der Plan enden kann.",
-  BUNDLE_NOT_PRICED_FOR_THIS_PLAN: "F\xFCr dieses Bundle ist im Plan {planKey} kein {billingCycle} Preis hinterlegt, es kann hier deshalb nicht gebucht werden.",
+  BUNDLE_NOT_PRICED_FOR_THIS_PLAN: "F\xFCr dieses Bundle ist im Plan {planKey} in diesem Abrechnungsrhythmus kein Preis hinterlegt, es kann hier deshalb nicht gebucht werden.",
+  BUNDLE_CANNOT_RUN_ON_UPCOMING_PLAN: "Dieses Bundle kann nicht im Plan {planKey} laufen, in den das Abonnement mit Wirkung ab {from} wechselt.",
+  BUNDLE_CANNOT_RUN_ON_UPCOMING_CYCLE: "Ein j\xE4hrlich abgerechnetes Bundle kann nicht neben der monatlichen Abrechnung laufen, auf die das Abonnement mit Wirkung ab {from} wechselt.",
   SUBSCRIPTION_BUNDLE_ALREADY_CANCELLED: "SubscriptionBundle '{subscriptionBundleId}' ist bereits gek\xFCndigt.",
   SUBSCRIPTION_BUNDLE_NOT_CANCELLED: "SubscriptionBundle '{subscriptionBundleId}' ist nicht gek\xFCndigt.",
   SUBSCRIPTION_BUNDLE_CANCELLATION_EFFECTIVE: "Die K\xFCndigung ist bereits wirksam \u2014 buche das Bundle einfach neu.",
@@ -1830,7 +2701,8 @@ var ERROR_MESSAGES_DE = {
   SUBSCRIPTION_TENANT_MISMATCH: "Das Abonnement geh\xF6rt nicht zu diesem Mandanten",
   SUBSCRIPTION_BUNDLE_NOT_FOUND: "SubscriptionBundle '{subscriptionBundleId}' nicht gefunden",
   TENANT_NOT_FOUND: "Mandant {slug} nicht gefunden",
-  NO_ACTIVE_PLAN_VERSION: "Zum {asOf} ist keine Planversion f\xFCr {planId} aktiv \u2014 weder ist das validFrom-Fenster erf\xFCllt, noch steht eine j\xFCngste Live-Version bereit.",
+  NO_ACTIVE_PLAN_VERSION: "Zum {asOf} ist keine Version des Plans {planId} im Verkauf.",
+  BOUND_PLAN_VERSION_UNREADABLE: 'Die Planversion, an die dieses Abonnement gebunden ist ({planVersionId}), ist f\xFCr den Plan "{planKey}" nicht lesbar; deshalb kann kein Wechsel berechnet werden.',
   PLAN_NOT_IN_CATALOG: 'Plan "{planKey}" steht nicht im Katalog',
   PLAN_NOT_SELF_SERVICE: "{planName} wird nur \xFCber einen Sondervertrag freigeschaltet. Bitte wenden Sie sich an die Vertragsverwaltung.",
   PLAN_NOT_SOLD_IN_CYCLE: "{planName} hat f\xFCr diesen Abrechnungsrhythmus keinen Preis und kann darin nicht gebucht werden.",
@@ -1838,6 +2710,25 @@ var ERROR_MESSAGES_DE = {
   SUBSCRIPTION_CHANGED: "Dieses Abonnement hat sich ge\xE4ndert, w\xE4hrend die Anfrage entschieden wurde. Bitte lade es neu.",
   NO_SUBSCRIPTION: "Dieser Mandant hat kein Abonnement, das gek\xFCndigt werden kann.",
   CANCELLATION_TERMS_CHANGED: "Das Wirksamkeitsdatum hat sich seit der Anzeige ge\xE4ndert. Bitte best\xE4tige das neue Datum.",
+  VERSION_OFFER_CHANGED: "Das Angebot hat sich seit der Anzeige ge\xE4ndert. Bitte sieh dir das aktuelle an, bevor du wechselst.",
+  PLAN_CHANGE_QUOTE_CHANGED: "Dieser Plan hat sich seit der Anzeige ge\xE4ndert. Bitte sieh ihn dir noch einmal an, bevor du wechselst.",
+  PLAN_CHANGE_VERSION_NOT_NAMED: "Ein Planwechsel muss die Version nennen, die seine Vorschau gezeigt hat.",
+  VERSION_SWITCH_AFTER_CANCELLATION: "Dieses Abonnement endet, bevor diese Version wirksam w\xFCrde. Ein Wechsel dorthin ist nicht m\xF6glich.",
+  VERSION_ENDS_BEFORE_SWITCH: "Diese Version wird nicht mehr verkauft, bevor sie wirksam w\xFCrde. Ein Wechsel dorthin ist nicht m\xF6glich.",
+  RETIREMENT_TERMS_NOT_CONFIRMED: "Eine Version f\xFCr laufende Abonnements stillzulegen, braucht eine Klausel in deinen AGB. Setze tenantBilling.orderlyRetirement.termsConfirmed in config/saas.yaml, sobald sie sie enthalten.",
+  RETIREMENT_VERSION_ON_SALE: "Version {version} von {planKey} wird noch verkauft. Beende zuerst ihren Verkauf, damit sie nach der Ank\xFCndigung niemand mehr bucht.",
+  RETIREMENT_REPLACEMENT_NOT_ON_SALE: "Version {version} von {planKey} wird nicht verkauft. Abonnements k\xF6nnen nicht auf ihr weiterlaufen.",
+  RETIREMENT_REPLACEMENT_NOT_SOLD_IN_RHYTHM: "{count} dieser Abonnements werden in einem Rhythmus abgerechnet, f\xFCr den Version {version} von {planKey} keinen Preis hat. Sie k\xF6nnen nicht auf ihr weiterlaufen.",
+  RETIREMENT_REPLACEMENT_CANNOT_CARRY_BUNDLES: "{count} dieser Abonnements halten ein Bundle, das in Version {version} von {planKey} nicht laufen kann. Sie k\xF6nnen nicht auf ihr weiterlaufen.",
+  RETIREMENT_REPLACEMENT_IS_RETIRED: "Eine Version kann nicht ihr eigener Ersatz sein.",
+  RETIREMENT_NOTHING_AFFECTED: "Kein laufendes Abonnement nutzt Version {version} von {planKey}. Es gibt niemanden zu benachrichtigen.",
+  RETIREMENT_WITHIN_TWELVE_MONTHS: "{count} dieser Abonnements waren in den letzten zw\xF6lf Monaten schon von einer Stilllegung betroffen. Ein Abonnement ist h\xF6chstens einmal im Jahr betroffen.",
+  RETIREMENT_PREVIEW_CHANGED: "Die Abonnements, die diese Stilllegung betrifft, haben sich seit der Anzeige ge\xE4ndert. Sieh sie dir noch einmal an, bevor du sie ank\xFCndigst.",
+  RETIREMENT_SWITCH_NOT_PENDING: "F\xFCr Ihre Version steht keine Einstellung mehr bevor. Es gibt nichts, wohin Sie wechseln k\xF6nnten.",
+  RETIREMENT_SWITCH_IN_TRIAL: "Der Wechsel ist m\xF6glich, sobald Ihre Testphase endet.",
+  RETIREMENT_SWITCH_BUNDLE_CANNOT_FOLLOW: "{bundleName} kann im Paket {planName} nicht laufen und l\xE4uft fr\xFChestens bis {until}. Ist es gek\xFCndigt, ist der Wechsel ab diesem Tag m\xF6glich.",
+  RETIREMENT_SWITCH_NOT_OPEN: "Dieses Abonnement kann gerade nicht wechseln: Eine \xC4nderung ist geplant, es ist beendet, oder sein Paket gilt f\xFCr einen Sondervertrag.",
+  RETIREMENT_SWITCH_CHANGED: "Die Einstellung hat sich seit der Anzeige ge\xE4ndert. Sehen Sie sie sich noch einmal an, bevor Sie wechseln.",
   SUBSCRIPTION_ENDED: "Dieses Abonnement ist beendet. Sein Paket kann nicht mehr gewechselt werden.",
   PLAN_LOCKED: "Aktiver Sondervertrag {planName} \u2014 f\xFCr einen Paketwechsel wenden Sie sich bitte an die Vertragsverwaltung.",
   QUOTA_OVER_TARGET: "Aktuelle Nutzung {used} \xFCberschreitet das Ziel-Limit {targetMax} ({quotaKey}) im Paket {planName}. Bitte zuerst die Nutzung reduzieren.",
@@ -1846,11 +2737,11 @@ var ERROR_MESSAGES_DE = {
   NO_CHANGE: "Zielpaket und Abrechnungsrhythmus entsprechen bereits dem aktuellen Stand.",
   CANCELLATION_LOCKS_THE_CYCLE: "Dieses Abonnement ist gek\xFCndigt, sein Abrechnungsrhythmus kann daher nicht wechseln. Das Paket schon \u2014 behalten Sie den aktuellen Rhythmus, um es heute zu wechseln.",
   CYCLE_SHORTENS_AT_TERM_END: "Ein monatlich abgerechnetes {planName} kann nicht innerhalb der laufenden Jahreslaufzeit beginnen. Das Upgrade greift zum Ende dieser Laufzeit; wer es sofort m\xF6chte, beh\xE4lt den j\xE4hrlichen Rhythmus.",
-  BUNDLE_BOOKING_OUTLASTS_TARGET_CYCLE: "Ein j\xE4hrlich abgerechnetes Bundle ist bis {until} gebucht. Ein monatlich abgerechnetes Paket kann es nicht tragen \u2014 k\xFCndigen Sie das Bundle zuerst, oder behalten Sie den j\xE4hrlichen Rhythmus.",
+  BUNDLE_BOOKING_OUTLASTS_TARGET_CYCLE: "{bundleName} wird j\xE4hrlich abgerechnet und l\xE4uft fr\xFChestens bis {until}; ein monatlich abgerechnetes Paket kann es nicht tragen. Ist es gek\xFCndigt, geht ein Wechsel durch, der an diesem Tag oder sp\xE4ter wirksam wird \u2014 oder behalten Sie den j\xE4hrlichen Rhythmus.",
+  BUNDLE_BOOKING_DOES_NOT_FIT_TARGET_PLAN: "{bundleName} kann im Paket {planName} nicht laufen und l\xE4uft fr\xFChestens bis {until}. Ist es gek\xFCndigt, geht ein Wechsel durch, der an diesem Tag oder sp\xE4ter wirksam wird \u2014 oder w\xE4hlen Sie ein anderes Paket.",
   REDUNDANT_FEATURES: "Der Plan oder ein anderes gebuchtes Bundle enth\xE4lt bereits {count} der Funktionen aus diesem Bundle \u2014 mit der Buchung werden sie doppelt bezahlt.",
   MINIMUM_TERM_BINDS: "Die Mindestlaufzeit reicht \xFCber das Ende der Periode hinaus \u2014 die K\xFCndigung wird erst zum Ende der Mindestlaufzeit wirksam.",
   BUNDLE_FEATURE_DEPENDENCY_UNSATISFIED: "Das Bundle setzt [{features}] voraus \u2014 weder im Plan noch in den aktiven Bundles vorhanden.",
-  NO_PENDING_PLAN_VERSION: "Es wartet keine Planversion auf eine Best\xE4tigung.",
   ONBOARDING_CREATE_FAILED: "Das Konto konnte nicht angelegt werden. Bitte versuche es noch einmal.",
   BUNDLE_PREVIEW_ARGUMENT_AMBIGUOUS: "Genau eines von bundleVersionId (Vorschau f\xFCrs Buchen) oder subscriptionBundleId (Vorschau f\xFCrs K\xFCndigen) muss angegeben sein.",
   SUBSCRIPTION_PK_MISSING: "Der Adapter hat einen SubscriptionUsageRecord ohne id geliefert. Bitte den Prim\xE4rschl\xFCssel der Subscription durchreichen (siehe SubscriptionUsageRecord.id).",
@@ -1858,7 +2749,7 @@ var ERROR_MESSAGES_DE = {
   QUOTA_DIMENSION_UNKNOWN: 'Unbekannte Quota-Dimension "{dimension}".',
   // ── promo ──
   PROMO_CODE_NOT_FOUND: "Code nicht gefunden",
-  PROMO_CODE_ALREADY_EXISTS: "Diesen Code gibt es bereits.",
+  PROMO_CODE_ALREADY_EXISTS: "Diesen Code gibt es bereits, oder ein gel\xF6schter Code tr\xE4gt ihn; ein gel\xF6schter Code beh\xE4lt seinen Namen.",
   PROMO_CODE_HAS_REDEMPTIONS: "Der Code wurde bereits eingel\xF6st oder ist f\xFCr einen laufenden Checkout reserviert \u2014 er l\xE4sst sich nicht per Soft-Delete entfernen. Pausiere ihn stattdessen.",
   PROMO_CODE_NOT_REDEEMABLE: "Der Code l\xE4sst sich nicht einl\xF6sen: {reason}",
   PROMO_CODE_FORMAT_INVALID: 'Der Code darf nur Gro\xDFbuchstaben, Ziffern, "-" und "_" enthalten (4\u201332 Zeichen).',
@@ -1899,6 +2790,7 @@ var ERROR_MESSAGES_DE = {
   SUBSCRIPTION_CONTRACT_NOT_FOUND: "SubscriptionContract '{contractId}' nicht gefunden",
   NO_ACTIVE_SUBSCRIPTION_CONTRACT: "Kein aktiver Abo-Vertrag f\xFCr Mandant {tenantId}",
   SUBSCRIPTION_CONTRACT_ALREADY_CLOSED: "SubscriptionContract '{contractId}' ist bereits geschlossen",
+  SUBSCRIPTION_CONTRACT_CHANGED: "Die Vertr\xE4ge von Mandant '{tenantId}' haben sich ge\xE4ndert, w\xE4hrend ein Nachfolger geschrieben wurde, oder einer beginnt nach dem Zeitpunkt, ab dem er g\xE4lte, sodass er neben einem anderen liefe. Es wurde nichts geschrieben.",
   // ── subscriber ──
   SUBSCRIBER_REQUIRED: "Mandant '{tenantId}' hat keinen Vertragspartner. Ohne ihn wird nichts vereinbart oder berechnet: Zuerst muss der Vertragspartner des Mandanten angelegt werden.",
   SUBSCRIBER_ALREADY_EXISTS: "Mandant '{tenantId}' hat bereits einen Vertragspartner.",
@@ -1934,7 +2826,16 @@ var ERROR_MESSAGES_DE = {
   // ── entitlement (code lives in upsell.types.ts) ──
   [FEATURE_NOT_LICENSED]: "Das Feature {featureKeys} ist im aktuellen Plan nicht enthalten.",
   // ── settings ──
-  SETTINGS_CHANGE_NOT_FOUND: "Keine aufgezeichnete Einstellungs\xE4nderung hat diese ID."
+  SETTINGS_CHANGE_NOT_FOUND: "Keine aufgezeichnete Einstellungs\xE4nderung hat diese ID.",
+  // ── maintenance ──
+  MAINTENANCE: "Die Anwendung wird gerade gewartet.",
+  MAINTENANCE_WINDOW_ALREADY_OPEN: "Es ist bereits ein Wartungsfenster offen. Verschiebe oder streiche es, bevor du ein weiteres ank\xFCndigst.",
+  MAINTENANCE_WINDOW_NOT_OPEN: "Kein offenes Wartungsfenster hat diese ID.",
+  MAINTENANCE_WINDOW_LOCKED: "Dieses Wartungsfenster ist gesperrt. Sein Beginn l\xE4sst sich nicht mehr verschieben, und beendet wird es durch Entsperren.",
+  MAINTENANCE_WINDOW_END_NOT_AFTER_START: "Das Ende eines Wartungsfensters muss nach seinem Beginn liegen.",
+  MAINTENANCE_WINDOW_END_IN_PAST: "Das Ende eines Wartungsfensters darf nicht in der Vergangenheit liegen.",
+  MAINTENANCE_TIME_INVALID: "{field} muss Datum und Uhrzeit mit Zeitzone sein, etwa 2026-10-02T22:00+02:00.",
+  MAINTENANCE_MESSAGE_TOO_LONG: "Die Nachricht darf h\xF6chstens {max} Zeichen lang sein."
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -1945,13 +2846,20 @@ var ERROR_MESSAGES_DE = {
   CATALOGUE_KEYS,
   CATALOG_ERROR_CODES,
   CONTRACT_ERROR_CODES,
+  CUSTOM_LIMITS_KEYS,
   ERROR_MESSAGES_DE,
   ERROR_MESSAGES_EN,
   FEATURE_NOT_LICENSED,
   ForeignPaymentMethodReferenceError,
   LEGAL_IDENTITY_FIELDS,
+  MAINTENANCE_CAPABILITY,
+  MAINTENANCE_ERROR_CODES,
+  MAINTENANCE_MESSAGE_MAX_LENGTH,
+  MAINTENANCE_STATE_MAX_AGE_SECONDS,
   MARKETING_PRIORITY_MAX,
   MARKETING_PRIORITY_MIN,
+  NO_SCHEDULED_CHANGE,
+  OPTIONAL_CANONICAL_MODELS,
   OTP_RATE_LIMIT_MAX_SENDS,
   OTP_RATE_LIMIT_WINDOW_MINUTES,
   OTP_TTL_MINUTES,
@@ -1966,62 +2874,108 @@ var ERROR_MESSAGES_DE = {
   PROMO_ERROR_CODES,
   PaymentCallbackRejectedError,
   PersistenceCapabilityError,
+  PersistenceRefusal,
   PlatformUserExistsError,
   REGISTRATION_ERROR_CODES,
   REGISTRATION_RESUME_TTL_MINUTES,
   REGISTRATION_STEP_BY_STATUS,
+  RETIREMENT_REMINDER_LEAD_DAYS,
   SETTINGS_ERROR_CODES,
   SETUP_ERROR_CODES,
   SUBSCRIBER_ACCOUNT_CAPABILITY,
   SUBSCRIBER_ERROR_CODES,
+  VERSION_RETIREMENT_CAPABILITY,
   applyPromo,
   assertPersistenceCapabilities,
   buildActivePlanVersionWhere,
   buildActiveVersionWhere,
   buildFeatureRequiresIndex,
   bundleDraftDefaults,
+  bundleKeyTaken,
   bundleStemDefaults,
   canonicalJson,
+  catalogDraftExists,
+  catalogVersionAlreadyPublished,
+  catalogVersionGone,
   classifyBundleVersionDiff,
   classifyIssuerChange,
   classifyPlanDiff,
+  classifyVersionOffer,
   collectUnsatisfiedRequires,
+  computeIncludedVat,
+  concurrencyGate,
+  concurrencyGateOf,
   contractPartiesOf,
   coverageExcludingSelf,
+  customLimitsReader,
   definedFields,
   diffSettings,
   formatCustomerNumber,
   formatErrorMessage,
+  grossFromNet,
   identityCorrectionDelta,
   isBundleRedundant,
   isForeignPaymentMethodReferenceError,
+  isMaintenanceAnnouncementLapsed,
+  isMaintenanceOverrun,
   isPaymentCallbackRejectedError,
+  isPersistenceRefusal,
   isPlatformUserExistsError,
+  isVersionActiveAt,
   isVersionEditable,
   issuerIdentityOf,
   keepOneRecommended,
+  maintenanceRetryAfterSeconds,
+  maintenanceStatusOf,
+  maintenanceWindowStatusOf,
+  maintenanceWindowViewOf,
+  marketingProjectionTaken,
+  membersLeftOut,
   missingRequiresFor,
   movedIdentityFields,
+  netFromGross,
+  noActivePlanVersion,
+  parseZonedInstant,
+  percentOf,
   pickActivePromo,
   planCatalogSettingsOf,
+  planKeyTaken,
+  planNotInCatalog,
   previousUtcDay,
+  promoCodeTaken,
   promoStatus,
   promotionOnPrice,
+  prorate,
+  readCustomLimits,
   readQuotaRecord,
   readQuotaValue,
   recordedIssuerIdentity,
   refuseForeignPaymentMethodReference,
   resolveBundleAvailability,
   resolveErrorMessage,
+  retirementCostsTheSubscription,
+  retirementReminderDueAt,
+  retirementReminderIsDue,
+  retirementSwitchTerms,
+  roundToCents,
   sameLegalIdentity,
+  scheduledChangeAfterWrite,
   selectChargeableBundles,
   settingsSubtreeOf,
   startOfUtcDay,
   subscriberChargeColumns,
   subscriberFromRegistration,
   subscriberPaymentMethodColumns,
+  subscriptionBundleAlreadyCancelled,
+  subscriptionBundleGone,
+  subscriptionContractGone,
+  subscriptionGone,
+  sumToCents,
   toBundleStemRow,
+  toCents,
   toContractLineItemRecord,
+  toDecimalString,
+  toMaintenanceWindowRecord,
   toPlanRow,
   toPlanVersionRow,
   toRunningContractIssuer,
@@ -2030,5 +2984,10 @@ var ERROR_MESSAGES_DE = {
   toSubscriberPaymentMethodRecord,
   toSubscriberRecord,
   toSubscriptionBundleRecord,
-  toSubscriptionContractRecord
+  toSubscriptionContractRecord,
+  toSubscriptionNoticeRecord,
+  toVersionRetirementRecord,
+  versionOnSale,
+  versionOnSaleOrNext,
+  versionSale
 });