@saasicat/core 1.0.0-rc.23 → 1.0.0-rc.25

package/dist/index.cjs

@@ -24,9 +24,11 @@ __export(index_exports, {
   AUTH_ERROR_CODES: () => AUTH_ERROR_CODES,
   BILLING_ERROR_CODES: () => BILLING_ERROR_CODES,
   BUNDLE_PRICE_LOOKUP_LIMIT: () => BUNDLE_PRICE_LOOKUP_LIMIT,
+  BUNDLE_VERSION_RETIREMENT_CAPABILITY: () => BUNDLE_VERSION_RETIREMENT_CAPABILITY,
   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,
@@ -38,6 +40,8 @@ __export(index_exports, {
   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,
@@ -52,69 +56,121 @@ __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_ATTENTION_CAPABILITY: () => SUBSCRIBER_ATTENTION_CAPABILITY,
+  SUBSCRIBER_ATTENTION_PAGE_SIZE: () => SUBSCRIBER_ATTENTION_PAGE_SIZE,
+  SUBSCRIBER_CORRECTION_CAPABILITY: () => SUBSCRIBER_CORRECTION_CAPABILITY,
   SUBSCRIBER_ERROR_CODES: () => SUBSCRIBER_ERROR_CODES,
+  SUBSCRIBER_INVOICE_ADDRESS_FIELDS: () => SUBSCRIBER_INVOICE_ADDRESS_FIELDS,
+  SUBSCRIBER_STANDING_CAPABILITY: () => SUBSCRIBER_STANDING_CAPABILITY,
+  SUBSCRIBER_TAX_ORIGIN_FIELDS: () => SUBSCRIBER_TAX_ORIGIN_FIELDS,
+  TAX_ERROR_CODES: () => TAX_ERROR_CODES,
+  TAX_TREATMENT_KINDS: () => TAX_TREATMENT_KINDS,
+  VERSION_RETIREMENT_CAPABILITY: () => VERSION_RETIREMENT_CAPABILITY,
   applyPromo: () => applyPromo,
   assertPersistenceCapabilities: () => assertPersistenceCapabilities,
   buildActivePlanVersionWhere: () => buildActivePlanVersionWhere,
   buildActiveVersionWhere: () => buildActiveVersionWhere,
   buildFeatureRequiresIndex: () => buildFeatureRequiresIndex,
   bundleDraftDefaults: () => bundleDraftDefaults,
+  bundleKeyTaken: () => bundleKeyTaken,
   bundleStemDefaults: () => bundleStemDefaults,
   canonicalJson: () => canonicalJson,
+  canonicalVatId: () => canonicalVatId,
+  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,
+  keepsVatIdCheck: () => keepsVatIdCheck,
   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,
+  taxOriginOf: () => taxOriginOf,
+  taxOriginWrite: () => taxOriginWrite,
+  taxTreatmentToJson: () => taxTreatmentToJson,
   toBundleStemRow: () => toBundleStemRow,
+  toBundleVersionRetirementRecord: () => toBundleVersionRetirementRecord,
+  toCents: () => toCents,
   toContractLineItemRecord: () => toContractLineItemRecord,
+  toDecimalString: () => toDecimalString,
   toMaintenanceWindowRecord: () => toMaintenanceWindowRecord,
   toPlanRow: () => toPlanRow,
   toPlanVersionRow: () => toPlanVersionRow,
@@ -123,8 +179,18 @@ __export(index_exports, {
   toSubscriberCorrectionRecord: () => toSubscriberCorrectionRecord,
   toSubscriberPaymentMethodRecord: () => toSubscriberPaymentMethodRecord,
   toSubscriberRecord: () => toSubscriberRecord,
+  toSubscriberTaxOriginChangeRecord: () => toSubscriberTaxOriginChangeRecord,
+  toSubscriberVatIdCheckRecord: () => toSubscriberVatIdCheckRecord,
   toSubscriptionBundleRecord: () => toSubscriptionBundleRecord,
-  toSubscriptionContractRecord: () => toSubscriptionContractRecord
+  toSubscriptionContractRecord: () => toSubscriptionContractRecord,
+  toSubscriptionNoticeRecord: () => toSubscriptionNoticeRecord,
+  toTaxOriginValues: () => toTaxOriginValues,
+  toTaxTreatment: () => toTaxTreatment,
+  toVersionRetirementRecord: () => toVersionRetirementRecord,
+  vatIdCheckFromStore: () => vatIdCheckFromStore,
+  versionOnSale: () => versionOnSale,
+  versionOnSaleOrNext: () => versionOnSaleOrNext,
+  versionSale: () => versionSale
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -141,7 +207,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 };
@@ -151,6 +218,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
@@ -204,6 +281,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);
@@ -226,7 +376,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
     };
@@ -235,7 +387,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
     };
@@ -413,11 +565,222 @@ 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,
+  "bundle-version-retired": true,
+  "bundle-version-retirement-reminder": true,
+  "bundle-version-offered": 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/bundle-version-retirement.types.ts
+var BUNDLE_VERSION_RETIREMENT_CAPABILITY = "bundleVersions.retire";
+
+// src/bundle-version-retirement-mapping.ts
+function toBundleVersionRetirementRecord(row) {
+  return {
+    id: row.id,
+    retired: {
+      bundleVersionId: row.retiredBundleVersionId,
+      bundleKey: row.retiredBundleKey,
+      version: row.retiredVersion
+    },
+    replacement: {
+      bundleVersionId: row.replacementBundleVersionId,
+      bundleKey: row.replacementBundleKey,
+      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 {
@@ -624,11 +987,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",
@@ -647,6 +1041,13 @@ var CATALOG_ERROR_CODES = {
   PLAN_NOT_FOUND: "PLAN_NOT_FOUND",
   PLAN_VERSION_NOT_FOUND: "PLAN_VERSION_NOT_FOUND",
   BUNDLE_NOT_FOUND: "BUNDLE_NOT_FOUND",
+  /**
+   * Bookings told that their add-on version is being retired have still to
+   * move onto a version of this add-on — waiting for their notice, for their
+   * date, or past it — and a deleted add-on is booked by nothing, the move
+   * included. Carries how many, and the add-on's key.
+   */
+  BUNDLE_DELETE_WHILE_RETIREMENT_MOVES_PENDING: "BUNDLE_DELETE_WHILE_RETIREMENT_MOVES_PENDING",
   BUNDLE_VERSION_NOT_FOUND: "BUNDLE_VERSION_NOT_FOUND",
   FEATURE_NOT_FOUND: "FEATURE_NOT_FOUND",
   QUOTA_NOT_FOUND: "QUOTA_NOT_FOUND",
@@ -687,6 +1088,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",
@@ -706,6 +1123,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",
   /**
@@ -728,6 +1151,182 @@ 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",
+  /**
+   * As `RETIREMENT_SWITCH_BUNDLE_CANNOT_FOLLOW`, where only the version the
+   * add-on continues on from a retirement's date cannot run beside the
+   * replacement's plan. The version it is on can, so cancelling it — it then
+   * ends before that date — lets the switch through. Given while that date
+   * is ahead and the add-on is not cancelled yet; otherwise the earlier code
+   * names the day it can end. Carries the add-on, that version, its date and
+   * the plan.
+   */
+  RETIREMENT_SWITCH_BUNDLE_REPLACEMENT_CANNOT_FOLLOW: "RETIREMENT_SWITCH_BUNDLE_REPLACEMENT_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",
+  // ── retiring an add-on version for running bookings ──
+  //
+  // An add-on retirement answers with the plan retirement's codes where the
+  // sentence is the same — terms not confirmed, a version named as its own
+  // replacement, twelve months, a preview that changed — and with these
+  // where it names an add-on rather than a plan.
+  /**
+   * The add-on version is still on sale: a booking made after the
+   * announcement would be on it without having been told. Carries the
+   * add-on key and the version.
+   */
+  BUNDLE_RETIREMENT_VERSION_ON_SALE: "BUNDLE_RETIREMENT_VERSION_ON_SALE",
+  /** The replacement is not on sale, so no booking can continue on it. Carries add-on key and version. */
+  BUNDLE_RETIREMENT_REPLACEMENT_NOT_ON_SALE: "BUNDLE_RETIREMENT_REPLACEMENT_NOT_ON_SALE",
+  /**
+   * The replacement is a version of another add-on. A booking continues on
+   * a version of its own add-on, so it stays the same booking with its term.
+   * Carries both add-on keys.
+   */
+  BUNDLE_RETIREMENT_REPLACEMENT_OF_ANOTHER_BUNDLE: "BUNDLE_RETIREMENT_REPLACEMENT_OF_ANOTHER_BUNDLE",
+  /**
+   * Some of the bookings it reaches run, at their date, beside a plan the
+   * replacement cannot run beside: not allowed there, without a price there
+   * in the booking's rhythm, or in a longer rhythm than the plan's. Carries
+   * how many, and the replacement's add-on key and version.
+   */
+  BUNDLE_RETIREMENT_REPLACEMENT_CANNOT_RUN: "BUNDLE_RETIREMENT_REPLACEMENT_CANNOT_RUN",
+  /** No running booking is on the version: there is nobody to tell. Carries add-on key and version. */
+  BUNDLE_RETIREMENT_NOTHING_AFFECTED: "BUNDLE_RETIREMENT_NOTHING_AFFECTED",
+  /**
+   * The booking is on an add-on version being retired, and was cancelled to
+   * end before it would move, so it was never told and nothing moves it.
+   * Reinstated, it would run on past the date on a version nobody sells;
+   * booking the replacement once it has ended is the way. Carries the add-on
+   * key, the version, the replacement's version and the day it can be booked
+   * from.
+   */
+  BUNDLE_RETIREMENT_REINSTATE_REFUSED: "BUNDLE_RETIREMENT_REINSTATE_REFUSED",
+  /**
+   * As `BUNDLE_RETIREMENT_REINSTATE_REFUSED`, where the replacement cannot
+   * run beside the plan the subscription is on when the booking ends, or
+   * beside one it is already set to move to after that, in any rhythm it
+   * could be booked in, so there is no version of the add-on to book.
+   * Carries the add-on key, the version and the replacement's version.
+   */
+  BUNDLE_RETIREMENT_REINSTATE_REPLACEMENT_CANNOT_RUN: "BUNDLE_RETIREMENT_REINSTATE_REPLACEMENT_CANNOT_RUN",
+  /**
+   * As `BUNDLE_RETIREMENT_REINSTATE_REFUSED`, where the subscription ends by
+   * the day the replacement could be booked from, so there is no day to
+   * name. Carries the add-on key, the version and the replacement's version.
+   */
+  BUNDLE_RETIREMENT_REINSTATE_SUBSCRIPTION_ENDS: "BUNDLE_RETIREMENT_REINSTATE_SUBSCRIPTION_ENDS",
+  /**
+   * The plan the add-on runs beside, or the rhythm it is billed in, changes
+   * before the date the booking was told — by a change scheduled, or by a
+   * retirement told that moves the subscription to another plan — so the
+   * price a switch now would hold is not the one the booking pays until
+   * then. Switching once the plan has changed, or waiting for the
+   * date, is the way. Carries the add-on and the date.
+   */
+  BUNDLE_RETIREMENT_SWITCH_PLAN_CHANGES: "BUNDLE_RETIREMENT_SWITCH_PLAN_CHANGES",
+  /**
+   * The add-on version the caller asked to switch a booking to is no longer
+   * the one offered beside it — another is on sale, the booking moved, or
+   * there is no offer. Nothing was switched. Carries the version named
+   * (`bundleVersionId`) and the current `offer`, or `null`, so the page can
+   * show it instead of guessing.
+   */
+  BUNDLE_VERSION_OFFER_CHANGED: "BUNDLE_VERSION_OFFER_CHANGED",
   // ── the preview routes' own blockers and warnings ──
   //
   // These travel inside a 200 response, in `blockers[]` and `warnings[]`, not
@@ -757,14 +1356,33 @@ 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",
+  /**
+   * A bundle the tenant already holds can run on the plan they are moving
+   * to, but the version it continues on from a retirement's date cannot.
+   * Cancelling it lets the change through at once: the booking then ends
+   * before that date and never reaches the version. Given while that date is
+   * ahead and the booking is not cancelled yet; otherwise
+   * `BUNDLE_BOOKING_DOES_NOT_FIT_TARGET_PLAN` names the day it can end.
+   * Carries the bundle, that version, its date and the plan.
+   */
+  BUNDLE_REPLACEMENT_DOES_NOT_FIT_TARGET_PLAN: "BUNDLE_REPLACEMENT_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
@@ -786,7 +1404,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",
   /**
@@ -835,6 +1452,21 @@ var CONTRACT_ERROR_CODES = {
    * describes. Nothing was written; load the offer and conclude it again.
    */
   CHECKOUT_OFFER_CHANGED: "CHECKOUT_OFFER_CHANGED",
+  /**
+   * An offer concludes a tenant's first contract, and this tenant has a
+   * contract in force at the moment the offer's would take effect, or one
+   * beginning after it. Concluded, the two would run side by side. Nothing
+   * was written; a running subscription changes through its plan and its
+   * add-ons. Carries the offer and the contract that runs.
+   */
+  CHECKOUT_OFFER_CONTRACT_IN_FORCE: "CHECKOUT_OFFER_CONTRACT_IN_FORCE",
+  /**
+   * The offer names a version of an add-on the tenant has booked in another
+   * version. Concluded, the contract would name a version the booking is not
+   * on. Nothing was written; a booking changes its version through the offer
+   * beside it. Carries the offer, the add-on, the booking and both versions.
+   */
+  CHECKOUT_OFFER_ADD_ON_BOOKED_IN_ANOTHER_VERSION: "CHECKOUT_OFFER_ADD_ON_BOOKED_IN_ANOTHER_VERSION",
   SUBSCRIPTION_CONTRACT_NOT_FOUND: "SUBSCRIPTION_CONTRACT_NOT_FOUND",
   NO_ACTIVE_SUBSCRIPTION_CONTRACT: "NO_ACTIVE_SUBSCRIPTION_CONTRACT",
   SUBSCRIPTION_CONTRACT_ALREADY_CLOSED: "SUBSCRIPTION_CONTRACT_ALREADY_CLOSED",
@@ -845,7 +1477,12 @@ var CONTRACT_ERROR_CODES = {
    * second attempt, or a contract begins after the moment the successor
    * would take effect. Nothing was written.
    */
-  SUBSCRIPTION_CONTRACT_CHANGED: "SUBSCRIPTION_CONTRACT_CHANGED"
+  SUBSCRIPTION_CONTRACT_CHANGED: "SUBSCRIPTION_CONTRACT_CHANGED",
+  /**
+   * A contract states a tax rate — `field` names where — other than the one
+   * the installation's tax adapter decides for its subscriber.
+   */
+  SUBSCRIPTION_CONTRACT_TAX_RATE_NOT_DECIDED: "SUBSCRIPTION_CONTRACT_TAX_RATE_NOT_DECIDED"
 };
 var SUBSCRIBER_ERROR_CODES = {
   /**
@@ -869,7 +1506,30 @@ var SUBSCRIBER_ERROR_CODES = {
   SUBSCRIBER_CORRECTION_ACTOR_REQUIRED: "SUBSCRIBER_CORRECTION_ACTOR_REQUIRED",
   SUBSCRIBER_CORRECTION_CHANGES_NOTHING: "SUBSCRIBER_CORRECTION_CHANGES_NOTHING",
   /** The operator declared another legal entity: that is a transfer, not an edit. */
-  SUBSCRIBER_TAKEOVER_IS_A_TRANSFER: "SUBSCRIBER_TAKEOVER_IS_A_TRANSFER"
+  SUBSCRIBER_TAKEOVER_IS_A_TRANSFER: "SUBSCRIBER_TAKEOVER_IS_A_TRANSFER",
+  /**
+   * A contact change named whether the subscriber is a business. That is part
+   * of its tax origin and changes as a recorded change naming who made it.
+   */
+  SUBSCRIBER_BUSINESS_STATUS_NOT_A_CONTACT: "SUBSCRIBER_BUSINESS_STATUS_NOT_A_CONTACT",
+  /** A change of the subscriber's contact details or business status did not say who makes it. */
+  SUBSCRIBER_CHANGE_ACTOR_REQUIRED: "SUBSCRIBER_CHANGE_ACTOR_REQUIRED",
+  /**
+   * Where a tax adapter decides, a contract names its subscriber only once
+   * the address an invoice names is complete (`SC-PRIC-032`): a party copied
+   * onto a contract incomplete cannot be completed afterwards. Carries
+   * `missing`, the empty fields, for a screen to name by their labels; the
+   * shipped sentence names all four rather than the keys.
+   */
+  SUBSCRIBER_IDENTITY_INCOMPLETE: "SUBSCRIBER_IDENTITY_INCOMPLETE",
+  /**
+   * A change of whether the subscriber is a business states no reason. It
+   * decides the tax treatment of the next invoice, so the change log keeps
+   * why it moved (`SC-PRIC-043`).
+   */
+  SUBSCRIBER_BUSINESS_STATUS_REASON_REQUIRED: "SUBSCRIBER_BUSINESS_STATUS_REASON_REQUIRED",
+  /** A check of the subscriber's VAT identification number was asked for, and it holds none. */
+  SUBSCRIBER_VAT_ID_MISSING: "SUBSCRIBER_VAT_ID_MISSING"
 };
 var REGISTRATION_ERROR_CODES = {
   PENDING_REGISTRATION_NOT_FOUND: "PENDING_REGISTRATION_NOT_FOUND",
@@ -974,6 +1634,29 @@ var MAINTENANCE_ERROR_CODES = {
   /** The message is longer than `MAINTENANCE_MESSAGE_MAX_LENGTH`. */
   MAINTENANCE_MESSAGE_TOO_LONG: "MAINTENANCE_MESSAGE_TOO_LONG"
 };
+var TAX_ERROR_CODES = {
+  /**
+   * The tax adapter answers that it does not support the subscriber's case;
+   * `adapter` names it and `reason` is its sentence. Nothing is concluded with
+   * a guessed tax (`SC-PRIC-039`).
+   */
+  TAX_TREATMENT_NOT_SUPPORTED: "TAX_TREATMENT_NOT_SUPPORTED",
+  /**
+   * The tax adapter needs the VAT identification number checked to treat the
+   * case, and the check did not complete — the service is unavailable, timed
+   * out, or answered in a way the adapter cannot read (`503`). Nothing is
+   * decided in the subscriber's favour on a number not checked
+   * (`SC-PRIC-040`): try again later. `adapter` names the adapter and
+   * `reason` says why.
+   */
+  TAX_VAT_ID_CHECK_NOT_COMPLETED: "TAX_VAT_ID_CHECK_NOT_COMPLETED",
+  /**
+   * A VAT identification number was to be checked, and `config/saas.yaml`
+   * names no tax adapter, which is what names the service to check with
+   * (`409`).
+   */
+  TAX_VAT_ID_CHECK_NOT_AVAILABLE: "TAX_VAT_ID_CHECK_NOT_AVAILABLE"
+};
 var PLATFORM_ERROR_CODES = {
   ...SETUP_ERROR_CODES,
   ...AUTH_ERROR_CODES,
@@ -985,7 +1668,8 @@ var PLATFORM_ERROR_CODES = {
   ...REGISTRATION_ERROR_CODES,
   ...PAYMENT_ERROR_CODES,
   ...SETTINGS_ERROR_CODES,
-  ...MAINTENANCE_ERROR_CODES
+  ...MAINTENANCE_ERROR_CODES,
+  ...TAX_ERROR_CODES
 };
 
 // src/errors.ts
@@ -1004,92 +1688,552 @@ 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"],
+  BundleVersionRetirement: ["tenantBilling.bundleVersionRetirements"],
+  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;
+  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();
+    }
+  };
+}
+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/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,
+// 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_DELETE_WHILE_RETIREMENT_MOVES_PENDING: "{count} bookings still move onto a version of {bundleKey}, as a retirement told them. The add-on can be deleted once they have.",
+  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.",
+  BUNDLE_RETIREMENT_VERSION_ON_SALE: "Version {version} of {bundleKey} is still on sale. Publish the version that replaces it, and retire this one once its sale has ended, so nobody books it after the announcement.",
+  BUNDLE_RETIREMENT_REPLACEMENT_NOT_ON_SALE: "Version {version} of {bundleKey} is not on sale, so bookings cannot continue on it.",
+  BUNDLE_RETIREMENT_REPLACEMENT_OF_ANOTHER_BUNDLE: "The replacement is a version of {replacementBundleKey}, not of {bundleKey}. A booking continues on a version of its own add-on.",
+  BUNDLE_RETIREMENT_REPLACEMENT_CANNOT_RUN: "{count} of these bookings run beside a plan that version {version} of {bundleKey} cannot run beside, so they cannot continue on it.",
+  BUNDLE_RETIREMENT_NOTHING_AFFECTED: "No running booking is on version {version} of {bundleKey}, so there is nobody to tell.",
+  BUNDLE_RETIREMENT_REINSTATE_REFUSED: "Version {version} of {bundleKey} is being retired, and this booking ends before it would move. Book version {replacementVersion} from {bookableFrom}, when this booking has ended.",
+  BUNDLE_RETIREMENT_REINSTATE_REPLACEMENT_CANNOT_RUN: "Version {version} of {bundleKey} is being retired, and this booking ends before it would move. Version {replacementVersion}, which replaces it, cannot run beside your plan, or beside one your subscription is set to move to.",
+  BUNDLE_RETIREMENT_REINSTATE_SUBSCRIPTION_ENDS: "Version {version} of {bundleKey} is being retired, and this booking ends before it would move. Your subscription ends by then as well.",
+  BUNDLE_RETIREMENT_SWITCH_PLAN_CHANGES: "{bundleName} moves to its new version on {date}, and your plan changes before then, so the price a switch would keep is not known yet. Switch once your plan has changed, or let it move on that date.",
+  BUNDLE_VERSION_OFFER_CHANGED: "The offer changed since it was shown. Look at the current one before switching.",
+  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_BUNDLE_REPLACEMENT_CANNOT_FOLLOW: "{bundleName} continues on version {version} from {from}, which cannot run on {planName}. Once it is cancelled, the switch can be made.",
+  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.",
+  BUNDLE_REPLACEMENT_DOES_NOT_FIT_TARGET_PLAN: "{bundleName} continues on version {version} from {from}, which cannot run on {planName}. Cancel it, and the change 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 ──
+  SUBSCRIPTION_CONTRACT_TAX_RATE_NOT_DECIDED: "The contract states {stated} % in {field}, and the tax adapter decides {decided} %.",
+  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.",
+  CHECKOUT_OFFER_CONTRACT_IN_FORCE: "Checkout offer '{offerId}' concludes a first contract, and this tenant already has one. A running subscription changes through its plan and its add-ons.",
+  CHECKOUT_OFFER_ADD_ON_BOOKED_IN_ANOTHER_VERSION: "Checkout offer '{offerId}' names version {offeredVersion} of add-on '{bundleKey}', which this tenant has booked in version {bookedVersion} (booking {subscriptionBundleId}). Its version changes through the offer beside the add-on.",
+  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_INCOMPLETE: "The subscriber's billing address is not complete yet: a contract names it only with street and number, postal code, city and country.",
+  SUBSCRIBER_IDENTITY_NOT_A_CONTACT: "{field} is part of the subscriber's legal identity and changes only as a correction, with a reason.",
+  SUBSCRIBER_BUSINESS_STATUS_REASON_REQUIRED: "A change of whether the subscriber is a business needs a reason.",
+  SUBSCRIBER_VAT_ID_MISSING: "The subscriber has no VAT identification number to check.",
+  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.",
+  SUBSCRIBER_BUSINESS_STATUS_NOT_A_CONTACT: "Whether the subscriber is a business is part of its tax origin and changes only as a recorded change that names who made it.",
+  SUBSCRIBER_CHANGE_ACTOR_REQUIRED: "A change of the subscriber's details has to say who makes it.",
+  // ── 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.",
+  // ── tax ──
+  TAX_TREATMENT_NOT_SUPPORTED: "The tax adapter {adapter} does not support this case: {reason}",
+  TAX_VAT_ID_CHECK_NOT_COMPLETED: "The VAT identification number could not be checked just now ({reason}). Please try again later.",
+  TAX_VAT_ID_CHECK_NOT_AVAILABLE: "This installation names no tax adapter, so no VAT identification number is checked."
+};
+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
@@ -1110,8 +2254,8 @@ function toPlanRow(row) {
     deletedAt: toIsoOrNull(row.deletedAt)
   };
 }
-function toPlanVersionRow(row, planKey, fields) {
-  const mapped = {
+function toPlanVersionRow(row, planKey) {
+  return {
     id: row.id,
     version: row.version,
     baseVersionId: row.baseVersionId,
@@ -1126,17 +2270,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;
@@ -1235,23 +2376,13 @@ 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,
   renewal: true,
   planChange: true,
   bundleBooking: true,
+  bundleChange: true,
   credit: true,
   correction: true
 };
@@ -1260,10 +2391,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,
@@ -1283,34 +2414,165 @@ 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.`
     );
   }
   return {
-    subscriberId: charge.subscriberId,
-    tenantId: charge.tenantId,
-    subscriptionId: charge.subscriptionId,
-    contractId: charge.contractId,
-    contractLineItemId: charge.contractLineItemId,
-    origin: charge.origin,
-    source: charge.source,
-    sourceRef: charge.sourceRef,
-    periodStart: charge.periodStart,
-    periodEnd: charge.periodEnd,
-    currency: charge.currency,
-    amountNet: charge.amountNet.toFixed(2),
-    bookedAt: charge.bookedAt
+    subscriberId: charge.subscriberId,
+    tenantId: charge.tenantId,
+    subscriptionId: charge.subscriptionId,
+    contractId: charge.contractId,
+    contractLineItemId: charge.contractLineItemId,
+    origin: charge.origin,
+    source: charge.source,
+    sourceRef: charge.sourceRef,
+    periodStart: charge.periodStart,
+    periodEnd: charge.periodEnd,
+    currency: charge.currency,
+    amountNet: charge.amountNet.toFixed(2),
+    bookedAt: charge.bookedAt
+  };
+}
+function keysOf(record) {
+  return Object.keys(record);
+}
+
+// src/subscriber-ledger.types.ts
+var SUBSCRIBER_ACCOUNT_CAPABILITY = "charges.read";
+
+// src/subscriber.types.ts
+var SUBSCRIBER_INVOICE_ADDRESS_FIELDS = [
+  "addressLine1",
+  "postalCode",
+  "city",
+  "country"
+];
+var SUBSCRIBER_STANDING_CAPABILITY = "subscribers.read";
+var SUBSCRIBER_ATTENTION_CAPABILITY = "subscribers.attention";
+var SUBSCRIBER_ATTENTION_PAGE_SIZE = 200;
+var SUBSCRIBER_CORRECTION_CAPABILITY = "subscribers.correct";
+var SUBSCRIBER_TAX_ORIGIN_FIELDS = ["country", "business", "vatId"];
+
+// src/tax.types.ts
+var TAX_TREATMENT_KINDS = [
+  "standard",
+  "reduced",
+  "exempt",
+  "reverse-charge",
+  "not-taxable",
+  "small-business"
+];
+
+// src/tax-origin.ts
+var VAT_ID_SEPARATORS = /[\s.-]/g;
+function canonicalVatId(written) {
+  const vatId = written.replace(VAT_ID_SEPARATORS, "").toUpperCase();
+  return vatId === "" ? null : vatId;
+}
+function taxOriginOf(subscriber, currentCheck) {
+  const validated = subscriber.vatId !== null && currentCheck?.valid === true && currentCheck.vatId === subscriber.vatId;
+  return {
+    country: subscriber.country,
+    business: subscriber.business,
+    vatId: subscriber.vatId,
+    validatedVatId: validated ? subscriber.vatId : null
+  };
+}
+function keepsVatIdCheck(held, counting, check) {
+  if (held.vatId === null || check.vatId !== held.vatId) return false;
+  if (held.vatIdSince !== null && check.checkedAt.getTime() < held.vatIdSince.getTime()) {
+    return false;
+  }
+  if (counting === null || counting.vatId !== held.vatId) return true;
+  return counting.checkedAt.getTime() <= check.checkedAt.getTime();
+}
+function toSubscriberVatIdCheckRecord(row) {
+  return {
+    id: row.id,
+    subscriberId: row.subscriberId,
+    vatId: row.vatId,
+    checkedAt: row.checkedAt,
+    valid: row.valid,
+    service: row.service,
+    confirmation: textEntries(row.confirmation),
+    recordedAt: row.recordedAt
+  };
+}
+function taxTreatmentToJson(treatment) {
+  return {
+    kind: treatment.kind,
+    rate: treatment.rate,
+    note: treatment.note,
+    adapter: { name: treatment.adapter.name, version: treatment.adapter.version }
+  };
+}
+function toTaxTreatment(value) {
+  if (!isObject(value)) return null;
+  const { kind, rate, note, adapter } = value;
+  if (!isTreatmentKind(kind)) return null;
+  if (typeof rate !== "number" || !Number.isFinite(rate)) return null;
+  if (note !== null && typeof note !== "string") return null;
+  if (!isObject(adapter)) return null;
+  if (typeof adapter.name !== "string" || typeof adapter.version !== "string") return null;
+  return { kind, rate, note, adapter: { name: adapter.name, version: adapter.version } };
+}
+function taxOriginWrite(current, next) {
+  const previous = {};
+  const changed = {};
+  for (const field of SUBSCRIBER_TAX_ORIGIN_FIELDS) {
+    const value = next[field];
+    if (value === void 0 || value === current[field]) continue;
+    previous[field] = current[field];
+    changed[field] = value;
+  }
+  return {
+    previous,
+    changed,
+    moved: Object.keys(changed).length > 0,
+    endsCountingVatIdCheck: Object.prototype.hasOwnProperty.call(changed, "vatId")
   };
 }
-function keysOf(record) {
-  return Object.keys(record);
+function toTaxOriginValues(value) {
+  if (!isObject(value)) return {};
+  const values = {};
+  for (const field of SUBSCRIBER_TAX_ORIGIN_FIELDS) {
+    if (!Object.prototype.hasOwnProperty.call(value, field)) continue;
+    const entry = value[field];
+    if (field === "business") {
+      values[field] = typeof entry === "boolean" ? entry : null;
+    } else {
+      values[field] = typeof entry === "string" ? entry : null;
+    }
+  }
+  return values;
+}
+function isTreatmentKind(value) {
+  return TAX_TREATMENT_KINDS.includes(value);
+}
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function vatIdCheckFromStore(value) {
+  if (!isObject(value)) return null;
+  const { vatId, checkedAt, valid, service, confirmation } = value;
+  const at = checkedAt instanceof Date ? checkedAt : new Date(String(checkedAt));
+  if (typeof vatId !== "string" || typeof valid !== "boolean" || typeof service !== "string") {
+    return null;
+  }
+  if (checkedAt === void 0 || checkedAt === null || Number.isNaN(at.getTime())) return null;
+  return { vatId, checkedAt: at, valid, service, confirmation: textEntries(confirmation) };
+}
+function textEntries(value) {
+  if (!isObject(value)) return {};
+  const entries = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (typeof entry === "string") entries[key] = entry;
+  }
+  return entries;
 }
-
-// src/subscriber-ledger.types.ts
-var SUBSCRIBER_ACCOUNT_CAPABILITY = "charges.read";
 
 // src/subscriber-mapping.ts
 function formatCustomerNumber(prefix, sequence) {
@@ -1329,6 +2591,7 @@ function toSubscriberRecord(row, tenantId) {
     vatId: row.vatId,
     taxNumber: row.taxNumber,
     invoiceEmail: row.invoiceEmail,
+    business: row.business,
     tenantId,
     migrated: row.migrated,
     createdAt: row.createdAt,
@@ -1346,6 +2609,17 @@ function toSubscriberCorrectionRecord(row) {
     correctedAt: row.correctedAt
   };
 }
+function toSubscriberTaxOriginChangeRecord(row) {
+  return {
+    id: row.id,
+    subscriberId: row.subscriberId,
+    previous: toTaxOriginValues(row.previous),
+    changed: toTaxOriginValues(row.changed),
+    changedBy: row.changedBy,
+    changedAt: row.changedAt,
+    reason: row.reason
+  };
+}
 function identityCorrectionDelta(current, corrected) {
   const previous = {};
   const next = {};
@@ -1409,7 +2683,9 @@ function subscriberFromRegistration(pending) {
     city: pending.city,
     country: pending.country,
     vatId: pending.vatId,
-    taxNumber: pending.taxNumber
+    taxNumber: pending.taxNumber,
+    business: pending.business,
+    vatIdCheck: vatIdCheckFromStore(pending.vatIdCheck)
   };
 }
 function toIdentityValues(value) {
@@ -1427,7 +2703,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,
@@ -1436,7 +2712,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,
@@ -1444,7 +2720,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
@@ -1510,6 +2786,8 @@ function toSubscriptionBundleRecord(row) {
     }),
     currentPeriodStart: row.currentPeriodStart ?? null,
     currentPeriodEnd: row.currentPeriodEnd ?? null,
+    pendingBundleVersionId: row.pendingBundleVersionId ?? null,
+    pendingVersionEffectiveAt: row.pendingVersionEffectiveAt ?? null,
     canceledAt: row.canceledAt,
     canceledEffectiveAt: row.canceledEffectiveAt,
     createdAt: row.createdAt,
@@ -1526,6 +2804,7 @@ function toSubscriptionContractRecord(row, lineItems) {
     subscriber: toSubscriberParty(row.subscriberSnapshot),
     issuer: isPlainObject2(row.issuerSnapshot) ? toIssuerParty(row.issuerSnapshot) : null,
     partiesMigrated: row.partiesMigrated,
+    taxTreatment: toTaxTreatment(row.taxTreatment),
     status: row.status,
     effectiveFrom: row.effectiveFrom,
     effectiveUntil: row.effectiveUntil,
@@ -1625,6 +2904,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) {
@@ -1663,227 +2988,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",
-  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/error-messages-de.ts
 var ERROR_MESSAGES_DE = {
   // ── setup ──
@@ -1907,7 +3011,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.",
@@ -1915,34 +3019,40 @@ 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",
   PLAN_VERSION_NOT_FOUND: "PlanVersion '{versionId}' nicht gefunden",
   BUNDLE_NOT_FOUND: "Bundle '{bundleId}' nicht gefunden",
+  BUNDLE_DELETE_WHILE_RETIREMENT_MOVES_PENDING: "{count} Buchungen ziehen noch auf eine Version von {bundleKey} um, wie eine Stilllegung es ihnen mitgeteilt hat. Das Add-on l\xE4sst sich l\xF6schen, sobald sie umgezogen sind.",
   BUNDLE_VERSION_NOT_FOUND: "BundleVersion '{bundleVersionId}' nicht gefunden",
   FEATURE_NOT_FOUND: "Feature '{featureKey}' nicht gefunden",
   QUOTA_NOT_FOUND: "Quota '{quotaKey}' nicht gefunden",
@@ -1962,10 +3072,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.",
@@ -1973,7 +3085,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.",
@@ -1981,6 +3094,36 @@ 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.",
+  BUNDLE_RETIREMENT_VERSION_ON_SALE: "Version {version} von {bundleKey} wird noch verkauft. Ver\xF6ffentliche die Version, die sie ersetzt, und lege diese still, sobald ihr Verkauf geendet hat, damit sie nach der Ank\xFCndigung niemand mehr bucht.",
+  BUNDLE_RETIREMENT_REPLACEMENT_NOT_ON_SALE: "Version {version} von {bundleKey} wird nicht verkauft. Buchungen k\xF6nnen nicht auf ihr weiterlaufen.",
+  BUNDLE_RETIREMENT_REPLACEMENT_OF_ANOTHER_BUNDLE: "Der Ersatz ist eine Version von {replacementBundleKey}, nicht von {bundleKey}. Eine Buchung l\xE4uft auf einer Version ihres eigenen Add-ons weiter.",
+  BUNDLE_RETIREMENT_REPLACEMENT_CANNOT_RUN: "{count} dieser Buchungen laufen neben einem Plan, neben dem Version {version} von {bundleKey} nicht laufen kann. Sie k\xF6nnen nicht auf ihr weiterlaufen.",
+  BUNDLE_RETIREMENT_NOTHING_AFFECTED: "Keine laufende Buchung nutzt Version {version} von {bundleKey}. Es gibt niemanden zu benachrichtigen.",
+  BUNDLE_RETIREMENT_REINSTATE_REFUSED: "Version {version} von {bundleKey} wird stillgelegt, und diese Buchung endet, bevor sie umziehen w\xFCrde. Buchen Sie Version {replacementVersion} ab dem {bookableFrom}, wenn diese Buchung beendet ist.",
+  BUNDLE_RETIREMENT_REINSTATE_REPLACEMENT_CANNOT_RUN: "Version {version} von {bundleKey} wird stillgelegt, und diese Buchung endet, bevor sie umziehen w\xFCrde. Version {replacementVersion}, die sie ersetzt, kann neben Ihrem Paket oder einem Paket, zu dem Ihr Abonnement wechselt, nicht laufen.",
+  BUNDLE_RETIREMENT_REINSTATE_SUBSCRIPTION_ENDS: "Version {version} von {bundleKey} wird stillgelegt, und diese Buchung endet, bevor sie umziehen w\xFCrde. Ihr Abonnement endet bis dahin ebenfalls.",
+  BUNDLE_RETIREMENT_SWITCH_PLAN_CHANGES: "{bundleName} zieht am {date} auf seine neue Version um, und Ihr Paket \xE4ndert sich vorher. Der Preis, den ein Wechsel halten w\xFCrde, steht deshalb noch nicht fest. Wechseln Sie, sobald Ihr Paket gewechselt hat, oder lassen Sie es an diesem Tag umziehen.",
+  BUNDLE_VERSION_OFFER_CHANGED: "Das Angebot hat sich seit der Anzeige ge\xE4ndert. Bitte sieh dir das aktuelle an, bevor du wechselst.",
+  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_BUNDLE_REPLACEMENT_CANNOT_FOLLOW: "{bundleName} l\xE4uft ab dem {from} auf Version {version} weiter, die im Paket {planName} nicht laufen kann. Ist es gek\xFCndigt, ist der Wechsel 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.",
@@ -1989,11 +3132,12 @@ 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.",
+  BUNDLE_REPLACEMENT_DOES_NOT_FIT_TARGET_PLAN: "{bundleName} l\xE4uft ab dem {from} auf Version {version} weiter, die im Paket {planName} nicht laufen kann. K\xFCndigen Sie es, dann geht der Wechsel durch \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).",
@@ -2001,7 +3145,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).',
@@ -2015,6 +3159,7 @@ var ERROR_MESSAGES_DE = {
   PROMO_WOULD_PRODUCE_ZERO_INVOICE: "Bei absoluten Betr\xE4gen muss der Rabatt unter dem niedrigsten anwendbaren Planpreis bleiben, oder allowZeroInvoice muss aktiviert sein.",
   PROMO_MAX_REDEMPTIONS_LOWERED: "maxRedemptions l\xE4sst sich nicht senken.",
   // ── contract ──
+  SUBSCRIPTION_CONTRACT_TAX_RATE_NOT_DECIDED: "Der Vertrag nennt in {field} {stated} %, der Steueradapter entscheidet {decided} %.",
   CHECKOUT_OFFER_LINE_ITEMS_REQUIRED: "Aus einem Checkout-Angebot entsteht nur ein einziger Vertrag, und das erst, wenn seine Positionen eingefroren sind.",
   CHECKOUT_OFFER_PLAN_LINE_ITEM_REQUIRED: "Ein Checkout-Angebot braucht eine eingefrorene Plan-Position.",
   CHECKOUT_OFFER_BUNDLE_LINE_ITEMS_REQUIRED: "Jede gew\xE4hlte Bundle-Version braucht eine eingefrorene Bundle-Position.",
@@ -2039,6 +3184,8 @@ var ERROR_MESSAGES_DE = {
   CHECKOUT_OFFER_ALREADY_CONSUMED: "Checkout-Angebot '{offerId}' wurde bereits eingel\xF6st \u2014 '{action}' ist nicht mehr m\xF6glich",
   CHECKOUT_OFFER_NOT_CONSUMED: "CheckoutOffer '{offerId}' muss eingel\xF6st sein, bevor der Vertrag entsteht",
   CHECKOUT_OFFER_CHANGED: "Checkout-Angebot '{offerId}' hat sich w\xE4hrend des Abschlusses ge\xE4ndert. Bitte neu laden.",
+  CHECKOUT_OFFER_CONTRACT_IN_FORCE: "Checkout-Angebot '{offerId}' schlie\xDFt einen ersten Vertrag ab, und dieser Mandant hat bereits einen. Ein laufendes Abo \xE4ndert sich \xFCber seinen Plan und seine Add-ons.",
+  CHECKOUT_OFFER_ADD_ON_BOOKED_IN_ANOTHER_VERSION: "Checkout-Angebot '{offerId}' nennt Version {offeredVersion} des Add-ons '{bundleKey}', das dieser Mandant in Version {bookedVersion} gebucht hat (Buchung {subscriptionBundleId}). Die Version wechselt \xFCber das Angebot neben dem Add-on.",
   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",
@@ -2049,11 +3196,16 @@ var ERROR_MESSAGES_DE = {
   SUBSCRIBER_NOT_FOUND: "Vertragspartner '{subscriberId}' nicht gefunden",
   SUBSCRIBER_LEGAL_NAME_REQUIRED: "Ein Vertragspartner braucht seinen rechtlichen Namen.",
   SUBSCRIBER_DETAIL_INVALID: "Das Feld {field} des Vertragspartners ist ung\xFCltig.",
+  SUBSCRIBER_IDENTITY_INCOMPLETE: "Die Rechnungsadresse des Vertragspartners ist noch nicht vollst\xE4ndig: Ein Vertrag nennt ihn nur mit Stra\xDFe und Hausnummer, PLZ, Ort und Land.",
+  SUBSCRIBER_BUSINESS_STATUS_REASON_REQUIRED: "Eine \xC4nderung, ob der Vertragspartner ein Unternehmen ist, braucht eine Begr\xFCndung.",
+  SUBSCRIBER_VAT_ID_MISSING: "Der Vertragspartner hat keine Umsatzsteuer-Identifikationsnummer, die sich pr\xFCfen lie\xDFe.",
   SUBSCRIBER_IDENTITY_NOT_A_CONTACT: "{field} geh\xF6rt zur rechtlichen Identit\xE4t des Vertragspartners und \xE4ndert sich nur als Korrektur mit Begr\xFCndung.",
   SUBSCRIBER_CORRECTION_REASON_REQUIRED: "Eine Korrektur der rechtlichen Identit\xE4t braucht eine Begr\xFCndung.",
   SUBSCRIBER_CORRECTION_ACTOR_REQUIRED: "Eine Korrektur der rechtlichen Identit\xE4t muss nennen, wer sie vornimmt.",
   SUBSCRIBER_CORRECTION_CHANGES_NOTHING: "Die Korrektur \xE4ndert nichts: Jeder genannte Wert ist bereits erfasst.",
   SUBSCRIBER_TAKEOVER_IS_A_TRANSFER: "\xDCbernimmt eine andere Rechtsperson, ist das eine \xDCbertragung und keine Korrektur; sie l\xE4sst sich nicht als \xC4nderung erfassen.",
+  SUBSCRIBER_BUSINESS_STATUS_NOT_A_CONTACT: "Ob der Vertragspartner ein Unternehmen ist, geh\xF6rt zu seiner steuerlichen Herkunft und \xE4ndert sich nur als erfasste \xC4nderung, die nennt, wer sie vornimmt.",
+  SUBSCRIBER_CHANGE_ACTOR_REQUIRED: "Eine \xC4nderung der Angaben des Vertragspartners muss nennen, wer sie vornimmt.",
   // ── registration ──
   PENDING_REGISTRATION_NOT_FOUND: "Diese Registrierung konnten wir nicht finden. Vielleicht ist sie bereits abgeschlossen oder verworfen.",
   PENDING_REGISTRATION_EXPIRED: "Diese Registrierung ist abgelaufen. Bitte fange noch einmal von vorn an.",
@@ -2087,7 +3239,11 @@ var ERROR_MESSAGES_DE = {
   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."
+  MAINTENANCE_MESSAGE_TOO_LONG: "Die Nachricht darf h\xF6chstens {max} Zeichen lang sein.",
+  // ── tax ──
+  TAX_TREATMENT_NOT_SUPPORTED: "Der Steueradapter {adapter} unterst\xFCtzt diesen Fall nicht: {reason}",
+  TAX_VAT_ID_CHECK_NOT_COMPLETED: "Die Umsatzsteuer-Identifikationsnummer lie\xDF sich gerade nicht pr\xFCfen ({reason}). Bitte sp\xE4ter erneut versuchen.",
+  TAX_VAT_ID_CHECK_NOT_AVAILABLE: "Diese Installation nennt keinen Steueradapter, darum wird keine Umsatzsteuer-Identifikationsnummer gepr\xFCft."
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -2095,9 +3251,11 @@ var ERROR_MESSAGES_DE = {
   AUTH_ERROR_CODES,
   BILLING_ERROR_CODES,
   BUNDLE_PRICE_LOOKUP_LIMIT,
+  BUNDLE_VERSION_RETIREMENT_CAPABILITY,
   CATALOGUE_KEYS,
   CATALOG_ERROR_CODES,
   CONTRACT_ERROR_CODES,
+  CUSTOM_LIMITS_KEYS,
   ERROR_MESSAGES_DE,
   ERROR_MESSAGES_EN,
   FEATURE_NOT_LICENSED,
@@ -2109,6 +3267,8 @@ var ERROR_MESSAGES_DE = {
   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,
@@ -2123,69 +3283,121 @@ 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_ATTENTION_CAPABILITY,
+  SUBSCRIBER_ATTENTION_PAGE_SIZE,
+  SUBSCRIBER_CORRECTION_CAPABILITY,
   SUBSCRIBER_ERROR_CODES,
+  SUBSCRIBER_INVOICE_ADDRESS_FIELDS,
+  SUBSCRIBER_STANDING_CAPABILITY,
+  SUBSCRIBER_TAX_ORIGIN_FIELDS,
+  TAX_ERROR_CODES,
+  TAX_TREATMENT_KINDS,
+  VERSION_RETIREMENT_CAPABILITY,
   applyPromo,
   assertPersistenceCapabilities,
   buildActivePlanVersionWhere,
   buildActiveVersionWhere,
   buildFeatureRequiresIndex,
   bundleDraftDefaults,
+  bundleKeyTaken,
   bundleStemDefaults,
   canonicalJson,
+  canonicalVatId,
+  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,
+  keepsVatIdCheck,
   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,
+  taxOriginOf,
+  taxOriginWrite,
+  taxTreatmentToJson,
   toBundleStemRow,
+  toBundleVersionRetirementRecord,
+  toCents,
   toContractLineItemRecord,
+  toDecimalString,
   toMaintenanceWindowRecord,
   toPlanRow,
   toPlanVersionRow,
@@ -2194,6 +3406,16 @@ var ERROR_MESSAGES_DE = {
   toSubscriberCorrectionRecord,
   toSubscriberPaymentMethodRecord,
   toSubscriberRecord,
+  toSubscriberTaxOriginChangeRecord,
+  toSubscriberVatIdCheckRecord,
   toSubscriptionBundleRecord,
-  toSubscriptionContractRecord
+  toSubscriptionContractRecord,
+  toSubscriptionNoticeRecord,
+  toTaxOriginValues,
+  toTaxTreatment,
+  toVersionRetirementRecord,
+  vatIdCheckFromStore,
+  versionOnSale,
+  versionOnSaleOrNext,
+  versionSale
 });