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

package/dist/index.cjs

@@ -20,49 +20,95 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  ACTIVE_SUBSCRIPTION_CONTRACT_STATUSES: () => ACTIVE_SUBSCRIPTION_CONTRACT_STATUSES,
   AUTH_ERROR_CODES: () => AUTH_ERROR_CODES,
   BILLING_ERROR_CODES: () => BILLING_ERROR_CODES,
+  BUNDLE_PRICE_LOOKUP_LIMIT: () => BUNDLE_PRICE_LOOKUP_LIMIT,
+  CATALOGUE_KEYS: () => CATALOGUE_KEYS,
   CATALOG_ERROR_CODES: () => CATALOG_ERROR_CODES,
   CONTRACT_ERROR_CODES: () => CONTRACT_ERROR_CODES,
   ERROR_MESSAGES_DE: () => ERROR_MESSAGES_DE,
   ERROR_MESSAGES_EN: () => ERROR_MESSAGES_EN,
   FEATURE_NOT_LICENSED: () => FEATURE_NOT_LICENSED,
+  ForeignPaymentMethodReferenceError: () => ForeignPaymentMethodReferenceError,
+  LEGAL_IDENTITY_FIELDS: () => LEGAL_IDENTITY_FIELDS,
+  MARKETING_PRIORITY_MAX: () => MARKETING_PRIORITY_MAX,
+  MARKETING_PRIORITY_MIN: () => MARKETING_PRIORITY_MIN,
   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,
   OTP_VERIFY_MAX_ATTEMPTS: () => OTP_VERIFY_MAX_ATTEMPTS,
   PASSWORD_RESET_TTL_MINUTES: () => PASSWORD_RESET_TTL_MINUTES,
+  PAYMENT_ERROR_CODES: () => PAYMENT_ERROR_CODES,
+  PAYMENT_METHOD_TYPES: () => PAYMENT_METHOD_TYPES,
   PENDING_CHECKOUT_TTL_DAYS: () => PENDING_CHECKOUT_TTL_DAYS,
   PENDING_EMAIL_TTL_HOURS: () => PENDING_EMAIL_TTL_HOURS,
   PENDING_ONBOARDING_TTL_DAYS: () => PENDING_ONBOARDING_TTL_DAYS,
   PLATFORM_ERROR_CODES: () => PLATFORM_ERROR_CODES,
   PROMO_ERROR_CODES: () => PROMO_ERROR_CODES,
+  PaymentCallbackRejectedError: () => PaymentCallbackRejectedError,
   PersistenceCapabilityError: () => PersistenceCapabilityError,
   PlatformUserExistsError: () => PlatformUserExistsError,
   REGISTRATION_ERROR_CODES: () => REGISTRATION_ERROR_CODES,
   REGISTRATION_RESUME_TTL_MINUTES: () => REGISTRATION_RESUME_TTL_MINUTES,
   REGISTRATION_STEP_BY_STATUS: () => REGISTRATION_STEP_BY_STATUS,
+  SETTINGS_ERROR_CODES: () => SETTINGS_ERROR_CODES,
   SETUP_ERROR_CODES: () => SETUP_ERROR_CODES,
+  SUBSCRIBER_ERROR_CODES: () => SUBSCRIBER_ERROR_CODES,
   applyPromo: () => applyPromo,
   assertPersistenceCapabilities: () => assertPersistenceCapabilities,
   buildActivePlanVersionWhere: () => buildActivePlanVersionWhere,
   buildActiveVersionWhere: () => buildActiveVersionWhere,
   buildFeatureRequiresIndex: () => buildFeatureRequiresIndex,
+  bundleDraftDefaults: () => bundleDraftDefaults,
+  bundleStemDefaults: () => bundleStemDefaults,
+  canonicalJson: () => canonicalJson,
   classifyBundleVersionDiff: () => classifyBundleVersionDiff,
+  classifyIssuerChange: () => classifyIssuerChange,
   classifyPlanDiff: () => classifyPlanDiff,
   collectUnsatisfiedRequires: () => collectUnsatisfiedRequires,
+  contractPartiesOf: () => contractPartiesOf,
   coverageExcludingSelf: () => coverageExcludingSelf,
+  definedFields: () => definedFields,
+  diffSettings: () => diffSettings,
+  formatCustomerNumber: () => formatCustomerNumber,
   formatErrorMessage: () => formatErrorMessage,
+  identityCorrectionDelta: () => identityCorrectionDelta,
   isBundleRedundant: () => isBundleRedundant,
+  isForeignPaymentMethodReferenceError: () => isForeignPaymentMethodReferenceError,
+  isPaymentCallbackRejectedError: () => isPaymentCallbackRejectedError,
   isPlatformUserExistsError: () => isPlatformUserExistsError,
   isVersionEditable: () => isVersionEditable,
+  issuerIdentityOf: () => issuerIdentityOf,
+  keepOneRecommended: () => keepOneRecommended,
   missingRequiresFor: () => missingRequiresFor,
+  movedIdentityFields: () => movedIdentityFields,
   pickActivePromo: () => pickActivePromo,
+  planCatalogSettingsOf: () => planCatalogSettingsOf,
+  previousUtcDay: () => previousUtcDay,
   promoStatus: () => promoStatus,
+  promotionOnPrice: () => promotionOnPrice,
+  readQuotaRecord: () => readQuotaRecord,
+  readQuotaValue: () => readQuotaValue,
+  recordedIssuerIdentity: () => recordedIssuerIdentity,
+  refuseForeignPaymentMethodReference: () => refuseForeignPaymentMethodReference,
   resolveBundleAvailability: () => resolveBundleAvailability,
   resolveErrorMessage: () => resolveErrorMessage,
+  sameLegalIdentity: () => sameLegalIdentity,
   selectChargeableBundles: () => selectChargeableBundles,
-  startOfUtcDay: () => startOfUtcDay
+  settingsSubtreeOf: () => settingsSubtreeOf,
+  startOfUtcDay: () => startOfUtcDay,
+  subscriberFromRegistration: () => subscriberFromRegistration,
+  subscriberPaymentMethodColumns: () => subscriberPaymentMethodColumns,
+  toBundleStemRow: () => toBundleStemRow,
+  toContractLineItemRecord: () => toContractLineItemRecord,
+  toPlanRow: () => toPlanRow,
+  toPlanVersionRow: () => toPlanVersionRow,
+  toRunningContractIssuer: () => toRunningContractIssuer,
+  toSubscriberCorrectionRecord: () => toSubscriberCorrectionRecord,
+  toSubscriberPaymentMethodRecord: () => toSubscriberPaymentMethodRecord,
+  toSubscriberRecord: () => toSubscriberRecord,
+  toSubscriptionContractRecord: () => toSubscriptionContractRecord
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -70,6 +116,11 @@ module.exports = __toCommonJS(index_exports);
 function startOfUtcDay(date) {
   return new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()));
 }
+function previousUtcDay(value) {
+  const result = new Date(value);
+  result.setUTCDate(result.getUTCDate() - 1);
+  return result;
+}
 function buildActivePlanVersionWhere(asOf, options = {}) {
   const asOfDayStart = startOfUtcDay(asOf);
   const validityWindow = [
@@ -86,6 +137,57 @@ function buildActivePlanVersionWhere(asOf, options = {}) {
 }
 var buildActiveVersionWhere = buildActivePlanVersionWhere;
 
+// src/bundle-draft-defaults.ts
+function bundleDraftDefaults(data) {
+  return {
+    baseVersionId: data.baseVersionId ?? null,
+    features: data.features,
+    quotas: data.quotas ?? {},
+    compatibility: data.compatibility ?? {},
+    pricingOverrides: data.pricingOverrides ?? [],
+    monthlyNet: data.monthlyNet ?? null,
+    yearlyNet: data.yearlyNet ?? null,
+    marketed: data.marketed ?? true,
+    changeNote: data.changeNote ?? "",
+    createdByUserId: data.createdByUserId ?? null
+  };
+}
+function bundleStemDefaults(data) {
+  return {
+    bundleKey: data.bundleKey,
+    label: data.label,
+    description: data.description ?? null,
+    icon: data.icon ?? null,
+    sortOrder: data.sortOrder ?? 0,
+    i18n: data.i18n ?? {}
+  };
+}
+function toBundleStemRow(row) {
+  return {
+    id: row.id,
+    bundleKey: row.bundleKey,
+    label: row.label,
+    description: row.description,
+    icon: row.icon,
+    sortOrder: row.sortOrder,
+    i18n: row.i18n !== null && typeof row.i18n === "object" && !Array.isArray(row.i18n) ? row.i18n : {},
+    createdAt: row.createdAt.toISOString(),
+    updatedAt: row.updatedAt.toISOString(),
+    deletedAt: row.deletedAt?.toISOString() ?? null
+  };
+}
+function definedFields(data, keys) {
+  const patch = {};
+  for (const key of keys) {
+    if (data[key] !== void 0) patch[key] = data[key];
+  }
+  return patch;
+}
+
+// src/catalog-entry.types.ts
+var MARKETING_PRIORITY_MIN = 0;
+var MARKETING_PRIORITY_MAX = 1e4;
+
 // src/promotion.types.ts
 function promoStatus(promo, today = /* @__PURE__ */ new Date()) {
   const from = new Date(promo.validFrom);
@@ -99,27 +201,33 @@ function pickActivePromo(promotions, targetKey, locale, cycle, today = /* @__PUR
   return matches[0] ?? null;
 }
 function applyPromo(promo, basePrice) {
+  const result = boundedPromo(promo, basePrice);
+  return result && result.discounted < result.original ? result : null;
+}
+function boundedPromo(promo, basePrice) {
   if (!promo || basePrice === null || basePrice === void 0) return null;
   if (promo.type === "percent" && typeof promo.value === "number") {
+    const pct = withinBounds(promo.value, 100);
     return {
       kind: "percent",
-      discounted: Math.round(basePrice * (100 - promo.value)) / 100,
+      discounted: Math.round(basePrice * (100 - pct)) / 100,
       original: basePrice,
-      pct: promo.value
+      pct
     };
   }
   if (promo.type === "amount" && typeof promo.value === "number") {
+    const saved = withinBounds(promo.value, basePrice);
     return {
       kind: "amount",
-      discounted: Math.max(0, basePrice - promo.value),
+      discounted: Math.round((basePrice - saved) * 100) / 100,
       original: basePrice,
-      saved: promo.value
+      saved
     };
   }
-  if (promo.type === "intro" && typeof promo.value === "object") {
+  if (promo.type === "intro" && typeof promo.value === "object" && promo.value !== null) {
     return {
       kind: "intro",
-      discounted: promo.value.price,
+      discounted: withinBounds(promo.value.price, basePrice),
       original: basePrice,
       months: promo.value.months
     };
@@ -129,26 +237,38 @@ function applyPromo(promo, basePrice) {
   }
   return null;
 }
+function withinBounds(value, upper) {
+  return Math.min(Math.max(value, 0), Math.max(upper, 0));
+}
+function promotionOnPrice(promotions, targetKey, locale, cycle, basePrice, today = /* @__PURE__ */ new Date(), targetType = "PLAN") {
+  const promotion = pickActivePromo(promotions, targetKey, locale, cycle, today, targetType);
+  const result = applyPromo(promotion, basePrice);
+  return promotion && result ? { promotion, result } : null;
+}
+
+// src/quota-value.ts
+function readQuotaValue(value) {
+  if (typeof value === "number") return Number.isFinite(value) ? value : null;
+  if (typeof value !== "string") return null;
+  if (value.trim() === "") return null;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+var UNCOUNTABLE = -1;
+function readQuotaRecord(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return {};
+  const quotas = {};
+  for (const [key, entry] of Object.entries(value)) {
+    quotas[key] = readQuotaValue(entry) ?? UNCOUNTABLE;
+  }
+  return quotas;
+}
 
 // src/version-diff.ts
 function classifyPlanDiff(oldV, newV) {
   const changes = [];
   appendFeatureChanges(changes, oldV.features, newV.features);
-  appendNumberChange(changes, "maxUsers", oldV.maxUsers, newV.maxUsers, "higherIsBetter");
-  appendNumberChange(
-    changes,
-    "maxVehicles",
-    oldV.maxVehicles,
-    newV.maxVehicles,
-    "higherIsBetter"
-  );
-  appendNumberChange(
-    changes,
-    "maxStorageGb",
-    oldV.maxStorageGb,
-    newV.maxStorageGb,
-    "higherIsBetter"
-  );
+  appendQuotaChanges(changes, oldV.quotas, newV.quotas);
   appendDecimalChange(changes, "monthlyNet", oldV.monthlyNet, newV.monthlyNet, "lowerIsBetter");
   appendDecimalChange(changes, "yearlyNet", oldV.yearlyNet, newV.yearlyNet, "lowerIsBetter");
   return buildResult(changes);
@@ -195,11 +315,6 @@ function appendFeatureChanges(out, oldFeatures, newFeatures) {
     });
   }
 }
-function appendNumberChange(out, field, oldValue, newValue, polarity) {
-  if (oldValue === newValue) return;
-  const direction = directionFromCmp(newValue - oldValue, polarity);
-  out.push({ field, oldValue, newValue, direction });
-}
 function appendDecimalChange(out, field, oldValue, newValue, polarity) {
   const oldNum = toNumber(oldValue);
   const newNum = toNumber(newValue);
@@ -230,16 +345,31 @@ function buildResult(changes) {
   return { nonRegressive, changes };
 }
 function appendQuotaChanges(out, oldQuotas, newQuotas) {
+  const at = (quotas, key) => Object.hasOwn(quotas, key) ? quotas[key] : 0;
   const allKeys = /* @__PURE__ */ new Set([...Object.keys(oldQuotas), ...Object.keys(newQuotas)]);
   for (const key of allKeys) {
-    const oldValue = oldQuotas[key] ?? 0;
-    const newValue = newQuotas[key] ?? 0;
+    const oldRaw = at(oldQuotas, key);
+    const newRaw = at(newQuotas, key);
+    if (oldRaw === newRaw) continue;
+    const oldValue = toQuotaNumber(oldRaw);
+    const newValue = toQuotaNumber(newRaw);
     if (oldValue === newValue) continue;
-    const direction = directionFromQuotaCmp(oldValue, newValue);
-    out.push({ field: `quotas.${key}`, oldValue, newValue, direction });
+    out.push({
+      field: `quotas.${key}`,
+      oldValue: reportableQuota(oldRaw, oldValue),
+      newValue: reportableQuota(newRaw, newValue),
+      direction: directionFromQuotaCmp(oldValue, newValue)
+    });
   }
 }
+function toQuotaNumber(value) {
+  return readQuotaValue(value) ?? Number.NaN;
+}
+function reportableQuota(raw, asNumber) {
+  return Number.isFinite(asNumber) ? asNumber : String(raw);
+}
 function directionFromQuotaCmp(oldValue, newValue) {
+  if (!Number.isFinite(oldValue) || !Number.isFinite(newValue)) return "REGRESSION";
   if (oldValue === -1 && newValue !== -1) return "REGRESSION";
   if (newValue === -1 && oldValue !== -1) return "IMPROVEMENT";
   return newValue > oldValue ? "IMPROVEMENT" : "REGRESSION";
@@ -267,6 +397,60 @@ function appendNullableDecimalChange(out, field, oldValue, newValue, polarity) {
   appendDecimalChange(out, field, oldValue, newValue, polarity);
 }
 
+// src/settings-subtree.ts
+var CATALOGUE_KEYS = /* @__PURE__ */ new Set([
+  "schemaVersion",
+  "features",
+  "plans"
+]);
+function planCatalogSettingsOf(catalog) {
+  return settingsSubtreeOf(catalog);
+}
+function settingsSubtreeOf(catalog) {
+  const settings = {};
+  for (const [key, value] of Object.entries(catalog)) {
+    if (CATALOGUE_KEYS.has(key)) continue;
+    if (value === void 0) continue;
+    settings[key] = value;
+  }
+  return settings;
+}
+function canonicalJson(value) {
+  const json = JSON.stringify(value, (_key, member) => {
+    if (member && typeof member === "object" && !Array.isArray(member)) {
+      const sorted = {};
+      for (const name of Object.keys(member).sort()) {
+        sorted[name] = member[name];
+      }
+      return sorted;
+    }
+    return member;
+  });
+  return json ?? "undefined";
+}
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function diffSettings(before, after) {
+  const differences = [];
+  collectDifferences(before, after, [], differences);
+  return differences.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+}
+function isObjectOrAbsent(value) {
+  return value === void 0 || isPlainObject(value);
+}
+function collectDifferences(before, after, path, out) {
+  if (isObjectOrAbsent(before) && isObjectOrAbsent(after) && (before || after)) {
+    const names = /* @__PURE__ */ new Set([...Object.keys(before ?? {}), ...Object.keys(after ?? {})]);
+    for (const name of names) {
+      collectDifferences(before?.[name], after?.[name], [...path, name], out);
+    }
+    return;
+  }
+  if (canonicalJson(before) === canonicalJson(after)) return;
+  out.push({ path: path.join("."), before, after });
+}
+
 // src/ports/persistence-ports.types.ts
 var PersistenceCapabilityError = class extends Error {
   constructor(missing, requiredBy) {
@@ -337,6 +521,8 @@ var CATALOG_ERROR_CODES = {
   BUNDLE_VERSION_SUPERSEDED: "BUNDLE_VERSION_SUPERSEDED",
   BUNDLE_VERSION_REGRESSION: "BUNDLE_VERSION_REGRESSION",
   BUNDLE_VERSION_ZERO_PRICE: "BUNDLE_VERSION_ZERO_PRICE",
+  BUNDLE_VERSION_NO_PRICE: "BUNDLE_VERSION_NO_PRICE",
+  BUNDLE_VERSION_NOT_PRICED_FOR_PLAN: "BUNDLE_VERSION_NOT_PRICED_FOR_PLAN",
   BUNDLE_VERSION_DISCARD_NOT_IMPLEMENTED: "BUNDLE_VERSION_DISCARD_NOT_IMPLEMENTED",
   BUNDLE_VERSION_VALID_FROM_REQUIRED: "BUNDLE_VERSION_VALID_FROM_REQUIRED",
   BUNDLE_VERSION_VALID_FROM_INVALID: "BUNDLE_VERSION_VALID_FROM_INVALID",
@@ -355,6 +541,12 @@ var CATALOG_ERROR_CODES = {
   FEATURE_NOT_FOUND: "FEATURE_NOT_FOUND",
   QUOTA_NOT_FOUND: "QUOTA_NOT_FOUND",
   PROMOTION_NOT_FOUND: "PROMOTION_NOT_FOUND",
+  /**
+   * A promotion's value 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.
+   */
+  PROMOTION_VALUE_INVALID: "PROMOTION_VALUE_INVALID",
   MARKETING_PROJECTION_NOT_FOUND: "MARKETING_PROJECTION_NOT_FOUND",
   // ── already exists ──
   PLAN_ALREADY_EXISTS: "PLAN_ALREADY_EXISTS",
@@ -366,7 +558,12 @@ var CATALOG_ERROR_CODES = {
   // ── discovery ──
   QUOTA_NOT_IN_DISCOVERY_SNAPSHOT: "QUOTA_NOT_IN_DISCOVERY_SNAPSHOT",
   DISCOVERY_STATUS_TRANSITION_INVALID: "DISCOVERY_STATUS_TRANSITION_INVALID",
-  DISCOVERY_NOT_INITIALIZED: "DISCOVERY_NOT_INITIALIZED"
+  DISCOVERY_NOT_INITIALIZED: "DISCOVERY_NOT_INITIALIZED",
+  // ── catalogue import ──
+  /** The uploaded document is not a plan catalog — unparseable, or not an object. */
+  PLAN_CATALOG_UNREADABLE: "PLAN_CATALOG_UNREADABLE",
+  /** It parsed, and then failed the schema or a cross-field rule. */
+  PLAN_CATALOG_INVALID: "PLAN_CATALOG_INVALID"
 };
 var BILLING_ERROR_CODES = {
   /**
@@ -378,6 +575,8 @@ var BILLING_ERROR_CODES = {
   BUNDLE_ALREADY_SUBSCRIBED: "BUNDLE_ALREADY_SUBSCRIBED",
   BUNDLE_INCOMPATIBLE_WITH_PLAN: "BUNDLE_INCOMPATIBLE_WITH_PLAN",
   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",
   SUBSCRIPTION_BUNDLE_ALREADY_CANCELLED: "SUBSCRIPTION_BUNDLE_ALREADY_CANCELLED",
   SUBSCRIPTION_BUNDLE_NOT_CANCELLED: "SUBSCRIPTION_BUNDLE_NOT_CANCELLED",
   SUBSCRIPTION_BUNDLE_CANCELLATION_EFFECTIVE: "SUBSCRIPTION_BUNDLE_CANCELLATION_EFFECTIVE",
@@ -392,8 +591,91 @@ var BILLING_ERROR_CODES = {
   PLAN_NOT_IN_CATALOG: "PLAN_NOT_IN_CATALOG",
   /** Plan exists but cannot be booked via self-service. */
   PLAN_NOT_SELF_SERVICE: "PLAN_NOT_SELF_SERVICE",
+  /**
+   * Plan carries no price for the requested billing cycle, so it is not sold
+   * in it: a plan without a yearly price is a monthly plan.
+   */
+  PLAN_NOT_SOLD_IN_CYCLE: "PLAN_NOT_SOLD_IN_CYCLE",
   /** Plan change refused. Carries `blockers[]` with their own codes. */
   PLAN_CHANGE_BLOCKED: "PLAN_CHANGE_BLOCKED",
+  /**
+   * The subscription moved between the read a request was decided on and the
+   * write it attempted, so nothing was written. The caller reloads and asks
+   * again.
+   */
+  SUBSCRIPTION_CHANGED: "SUBSCRIPTION_CHANGED",
+  /**
+   * The tenant has no subscription to act on.
+   *
+   * `SUBSCRIPTION_NOT_FOUND` states the same fact on the read routes. Both
+   * are already on the wire and a code is renamed only deliberately, so both
+   * are named here rather than one being dropped behind a consumer's back.
+   */
+  NO_SUBSCRIPTION: "NO_SUBSCRIPTION",
+  /**
+   * The cancellation date the reader was shown is no longer the one the rules
+   * return, so the confirmation is refused rather than silently applied.
+   * Carries the recomputed dates, so the page can re-ask instead of guessing.
+   */
+  CANCELLATION_TERMS_CHANGED: "CANCELLATION_TERMS_CHANGED",
+  // ── the preview routes' own blockers and warnings ──
+  //
+  // These travel inside a 200 response, in `blockers[]` and `warnings[]`, not
+  // as thrown errors — but they are read by a person and so belong in the same
+  // catalogue. Each carries `params` with the values its sentence names. Two
+  // routes emit them: the plan-change preview and the bundle preview.
+  //
+  // Three of them used to construct their code from the subject:
+  // `VEHICLES_OVER_TARGET`, `ENTERPRISE_LOCKED`, `PRO_NOT_SELF_SERVICE`. That
+  // made the set grow with every quota and plan an installation defines, so no
+  // catalogue could be complete against it and no guard could check one. The
+  // subject is a parameter now.
+  /** The subscription has ended; its plan can no longer be changed. */
+  SUBSCRIPTION_ENDED: "SUBSCRIPTION_ENDED",
+  /** An active special contract blocks self-service plan changes. */
+  PLAN_LOCKED: "PLAN_LOCKED",
+  /** Current usage of one quota exceeds what the target plan allows. */
+  QUOTA_OVER_TARGET: "QUOTA_OVER_TARGET",
+  /** The change drops features the tenant has today. */
+  FEATURE_LOST: "FEATURE_LOST",
+  FEATURES_LOST: "FEATURES_LOST",
+  /** Target plan and cycle already match what is in place. */
+  NO_CHANGE: "NO_CHANGE",
+  /** A shorter cycle cannot start inside the term already running. */
+  CYCLE_SHORTENS_AT_TERM_END: "CYCLE_SHORTENS_AT_TERM_END",
+  /** A cancelled subscription cannot change its billing cycle. */
+  CANCELLATION_LOCKS_THE_CYCLE: "CANCELLATION_LOCKS_THE_CYCLE",
+  /**
+   * A bundle the tenant already holds runs past the cycle they are moving to.
+   *
+   * 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.
+   */
+  BUNDLE_BOOKING_OUTLASTS_TARGET_CYCLE: "BUNDLE_BOOKING_OUTLASTS_TARGET_CYCLE",
+  /**
+   * 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
+   * the customer's decision, and the preview only has to say so first.
+   */
+  REDUNDANT_FEATURES: "REDUNDANT_FEATURES",
+  /**
+   * A booking's minimum term outlasts the period being cancelled, so the
+   * cancellation takes effect at the end of the term, not of the period.
+   */
+  MINIMUM_TERM_BINDS: "MINIMUM_TERM_BINDS",
+  /**
+   * The previewed bundle requires features that neither the plan nor an
+   * active booking provides.
+   *
+   * The same string is a `StrictModeWarningCode` in `bundle.types.ts`, where
+   * it names the catalogue-authoring reading of the rule and travels with its
+   * own message. This declaration is the booking preview's blocker, which a
+   * 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",
@@ -413,20 +695,64 @@ var CONTRACT_ERROR_CODES = {
   CHECKOUT_OFFER_BUNDLE_LINE_ITEMS_REQUIRED: "CHECKOUT_OFFER_BUNDLE_LINE_ITEMS_REQUIRED",
   CHECKOUT_OFFER_BUNDLE_VERSION_NOT_BOOKABLE: "CHECKOUT_OFFER_BUNDLE_VERSION_NOT_BOOKABLE",
   CHECKOUT_OFFER_FEATURE_DEPENDENCY_UNSATISFIED: "CHECKOUT_OFFER_FEATURE_DEPENDENCY_UNSATISFIED",
+  CHECKOUT_OFFER_PLAN_NOT_OFFERED: "CHECKOUT_OFFER_PLAN_NOT_OFFERED",
+  CHECKOUT_OFFER_BUNDLE_NOT_OFFERED: "CHECKOUT_OFFER_BUNDLE_NOT_OFFERED",
+  CHECKOUT_OFFER_PROMO_CODE_NOT_ACCEPTED: "CHECKOUT_OFFER_PROMO_CODE_NOT_ACCEPTED",
+  CHECKOUT_OFFER_PRICE_NOT_CURRENT: "CHECKOUT_OFFER_PRICE_NOT_CURRENT",
   SUBSCRIPTION_CONTRACT_LINE_ITEMS_REQUIRED: "SUBSCRIPTION_CONTRACT_LINE_ITEMS_REQUIRED",
   SUBSCRIPTION_CONTRACT_PLAN_LINE_ITEM_REQUIRED: "SUBSCRIPTION_CONTRACT_PLAN_LINE_ITEM_REQUIRED",
   SUBSCRIPTION_CONTRACT_INVALID_DATE: "SUBSCRIPTION_CONTRACT_INVALID_DATE",
   SUBSCRIPTION_CONTRACT_INVALID_WINDOW: "SUBSCRIPTION_CONTRACT_INVALID_WINDOW",
+  SUBSCRIPTION_CONTRACT_LINE_ITEM_TAX_MISMATCH: "SUBSCRIPTION_CONTRACT_LINE_ITEM_TAX_MISMATCH",
+  SUBSCRIPTION_CONTRACT_TAX_RATE_NOT_PERCENT: "SUBSCRIPTION_CONTRACT_TAX_RATE_NOT_PERCENT",
+  SUBSCRIPTION_CONTRACT_LINE_ITEM_CURRENCY_MISMATCH: "SUBSCRIPTION_CONTRACT_LINE_ITEM_CURRENCY_MISMATCH",
+  /**
+   * The lines do not add up to a total the contract states, counted as often
+   * as each falls due in one period. `field` names the total.
+   */
+  SUBSCRIPTION_CONTRACT_LINES_DO_NOT_ADD_UP: "SUBSCRIPTION_CONTRACT_LINES_DO_NOT_ADD_UP",
+  /** Something that takes money off states a negative amount. */
+  SUBSCRIPTION_CONTRACT_DISCOUNT_NEGATIVE: "SUBSCRIPTION_CONTRACT_DISCOUNT_NEGATIVE",
   SUBSCRIPTION_CONTRACT_TERMINATION_BEFORE_START: "SUBSCRIPTION_CONTRACT_TERMINATION_BEFORE_START",
   // ── stage 3 ──
   CHECKOUT_OFFER_NOT_FOUND: "CHECKOUT_OFFER_NOT_FOUND",
   CHECKOUT_OFFER_EXPIRED: "CHECKOUT_OFFER_EXPIRED",
   CHECKOUT_OFFER_ALREADY_CONSUMED: "CHECKOUT_OFFER_ALREADY_CONSUMED",
   CHECKOUT_OFFER_NOT_CONSUMED: "CHECKOUT_OFFER_NOT_CONSUMED",
+  /**
+   * The offer changed between the checks of `conclude` and the transaction
+   * that consumed it, so the contract checked is not the one the offer now
+   * describes. Nothing was written; load the offer and conclude it again.
+   */
+  CHECKOUT_OFFER_CHANGED: "CHECKOUT_OFFER_CHANGED",
   SUBSCRIPTION_CONTRACT_NOT_FOUND: "SUBSCRIPTION_CONTRACT_NOT_FOUND",
   NO_ACTIVE_SUBSCRIPTION_CONTRACT: "NO_ACTIVE_SUBSCRIPTION_CONTRACT",
   SUBSCRIPTION_CONTRACT_ALREADY_CLOSED: "SUBSCRIPTION_CONTRACT_ALREADY_CLOSED"
 };
+var SUBSCRIBER_ERROR_CODES = {
+  /**
+   * A contract, a plan change or a booking for a tenant that has no
+   * subscriber. Nothing is agreed or charged without the party to it.
+   * Carries `tenantId`.
+   */
+  SUBSCRIBER_REQUIRED: "SUBSCRIBER_REQUIRED",
+  /** The tenant already has a live subscriber. Carries `tenantId`. */
+  SUBSCRIBER_ALREADY_EXISTS: "SUBSCRIBER_ALREADY_EXISTS",
+  SUBSCRIBER_NOT_FOUND: "SUBSCRIBER_NOT_FOUND",
+  SUBSCRIBER_LEGAL_NAME_REQUIRED: "SUBSCRIBER_LEGAL_NAME_REQUIRED",
+  /**
+   * A detail that has a form — the country, the invoice email — is not in it,
+   * or one sign-up requires — the billing address — is missing. Carries `field`.
+   */
+  SUBSCRIBER_DETAIL_INVALID: "SUBSCRIBER_DETAIL_INVALID",
+  /** A contact change named a field of the legal identity. Carries `field`. */
+  SUBSCRIBER_IDENTITY_NOT_A_CONTACT: "SUBSCRIBER_IDENTITY_NOT_A_CONTACT",
+  SUBSCRIBER_CORRECTION_REASON_REQUIRED: "SUBSCRIBER_CORRECTION_REASON_REQUIRED",
+  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"
+};
 var REGISTRATION_ERROR_CODES = {
   PENDING_REGISTRATION_NOT_FOUND: "PENDING_REGISTRATION_NOT_FOUND",
   PENDING_REGISTRATION_EXPIRED: "PENDING_REGISTRATION_EXPIRED",
@@ -452,6 +778,12 @@ var AUTH_ERROR_CODES = {
   /** Neither `tenantId` nor `userId` could be resolved from the request. */
   TENANT_CONTEXT_MISSING: "TENANT_CONTEXT_MISSING",
   TENANT_ADMIN_REQUIRED: "TENANT_ADMIN_REQUIRED",
+  /**
+   * The tenant's billing area — its payment method, and later its invoices
+   * and account — needs the billing permission, which the application maps
+   * to its roles and the tenant's administrator holds by default.
+   */
+  BILLING_PERMISSION_REQUIRED: "BILLING_PERMISSION_REQUIRED",
   SUPER_ADMIN_REQUIRED: "SUPER_ADMIN_REQUIRED",
   /** TOTP MFA has never been set up for this user. */
   MFA_NOT_SET_UP: "MFA_NOT_SET_UP",
@@ -479,6 +811,26 @@ var PROMO_ERROR_CODES = {
   PROMO_WOULD_PRODUCE_ZERO_INVOICE: "PROMO_WOULD_PRODUCE_ZERO_INVOICE",
   PROMO_MAX_REDEMPTIONS_LOWERED: "PROMO_MAX_REDEMPTIONS_LOWERED"
 };
+var PAYMENT_ERROR_CODES = {
+  /**
+   * No gateway account takes new payment methods:
+   * `config/saas.yaml#payments.newPaymentMethods` names none.
+   */
+  PAYMENTS_NOT_CONFIGURED: "PAYMENTS_NOT_CONFIGURED",
+  /** A callback arrived for an account `config/saas.yaml#payments.accounts` does not name. Carries `account`. */
+  PAYMENT_GATEWAY_ACCOUNT_UNKNOWN: "PAYMENT_GATEWAY_ACCOUNT_UNKNOWN",
+  /** A callback the gateway did not send: its signature does not verify. */
+  PAYMENT_CALLBACK_REJECTED: "PAYMENT_CALLBACK_REJECTED",
+  /**
+   * A success or cancel URL at an origin `config/saas.yaml#payments.returnUrlOrigins`
+   * does not name. Carries `field`.
+   */
+  PAYMENT_RETURN_URL_NOT_ALLOWED: "PAYMENT_RETURN_URL_NOT_ALLOWED"
+};
+var SETTINGS_ERROR_CODES = {
+  /** No recorded change has this id, or the installation keeps no record at all. */
+  SETTINGS_CHANGE_NOT_FOUND: "SETTINGS_CHANGE_NOT_FOUND"
+};
 var PLATFORM_ERROR_CODES = {
   ...SETUP_ERROR_CODES,
   ...AUTH_ERROR_CODES,
@@ -486,7 +838,10 @@ var PLATFORM_ERROR_CODES = {
   ...CATALOG_ERROR_CODES,
   ...BILLING_ERROR_CODES,
   ...CONTRACT_ERROR_CODES,
-  ...REGISTRATION_ERROR_CODES
+  ...SUBSCRIBER_ERROR_CODES,
+  ...REGISTRATION_ERROR_CODES,
+  ...PAYMENT_ERROR_CODES,
+  ...SETTINGS_ERROR_CODES
 };
 
 // src/errors.ts
@@ -565,6 +920,19 @@ function selectChargeableBundles(planFeatures, selectedBundles) {
   }
 }
 
+// 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;
@@ -584,6 +952,442 @@ var REGISTRATION_STEP_BY_STATUS = {
 };
 var REGISTRATION_RESUME_TTL_MINUTES = 60;
 
+// src/plan-mapping.ts
+function toPlanRow(row) {
+  return {
+    id: row.id,
+    planKey: row.planKey,
+    label: row.label,
+    description: row.description,
+    icon: row.icon,
+    sortOrder: row.sortOrder,
+    createdAt: row.createdAt.toISOString(),
+    updatedAt: row.updatedAt.toISOString(),
+    deletedAt: toIsoOrNull(row.deletedAt)
+  };
+}
+function toPlanVersionRow(row, planKey, fields) {
+  const mapped = {
+    id: row.id,
+    version: row.version,
+    baseVersionId: row.baseVersionId,
+    planId: planKey,
+    features: toFeatureKeys(row.features),
+    quotas: toQuotaEffects(row.quotas),
+    monthlyNet: String(row.monthlyNet),
+    yearlyNet: String(row.yearlyNet),
+    marketed: row.marketed,
+    publishedAt: toIsoOrNull(row.publishedAt),
+    supersededAt: toIsoOrNull(row.supersededAt),
+    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,
+    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;
+}
+function toFeatureKeys(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((entry) => typeof entry === "string");
+}
+function toQuotaEffects(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return {};
+  }
+  const quotas = {};
+  for (const [key, entry] of Object.entries(value)) {
+    quotas[key] = readQuotaValue(entry) ?? Number.NaN;
+  }
+  return quotas;
+}
+
+// src/legal-identity.ts
+var LEGAL_IDENTITY_FIELDS = [
+  "legalName",
+  "vatId",
+  "taxNumber"
+];
+function sameLegalIdentity(before, after) {
+  return LEGAL_IDENTITY_FIELDS.every((field) => before[field] === after[field]);
+}
+function movedIdentityFields(before, after) {
+  return LEGAL_IDENTITY_FIELDS.filter((field) => before[field] !== after[field]);
+}
+
+// src/issuer-identity.ts
+function issuerIdentityOf(issuer) {
+  if (!issuer) return null;
+  return identityOf({
+    legalName: issuer.legalName,
+    vatId: issuer.vatId,
+    taxNumber: issuer.taxNumber
+  });
+}
+function recordedIssuerIdentity(settings) {
+  const issuer = settings?.issuer;
+  if (issuer === null || typeof issuer !== "object" || Array.isArray(issuer)) return null;
+  return identityOf(issuer);
+}
+function identityOf(source) {
+  const legalName = textOrNull(source.legalName);
+  if (legalName === null) return null;
+  return {
+    legalName,
+    vatId: textOrNull(source.vatId),
+    taxNumber: textOrNull(source.taxNumber)
+  };
+}
+function classifyIssuerChange(recorded, issuer) {
+  const current = issuerIdentityOf(issuer);
+  if (!recorded)
+    return current ? { kind: "first-naming", identity: current } : { kind: "none-named" };
+  if (current && sameLegalIdentity(recorded, current))
+    return { kind: "unchanged", identity: current };
+  if (!current) {
+    const moved2 = LEGAL_IDENTITY_FIELDS.filter((field) => recorded[field] !== null);
+    return {
+      kind: "undeclared",
+      recorded,
+      current: null,
+      moved: moved2,
+      fault: { kind: "names-no-issuer" }
+    };
+  }
+  const moved = movedIdentityFields(recorded, current);
+  const fault = faultIn(issuer?.correctionOf, recorded, moved);
+  if (fault) return { kind: "undeclared", recorded, current, moved, fault };
+  const declaration = issuer?.correctionOf;
+  return { kind: "corrected", recorded, current, moved, reason: declaration.reason };
+}
+function faultIn(declaration, recorded, moved) {
+  if (!declaration) return { kind: "absent" };
+  for (const field of LEGAL_IDENTITY_FIELDS) {
+    if (!Object.prototype.hasOwnProperty.call(declaration, field)) continue;
+    const declared = textOrNull(declaration[field]);
+    if (declared !== recorded[field]) {
+      return { kind: "names-another-value", field, declared, recorded: recorded[field] };
+    }
+  }
+  for (const field of moved) {
+    if (Object.prototype.hasOwnProperty.call(declaration, field)) continue;
+    return { kind: "leaves-a-field-out", field, recorded: recorded[field] };
+  }
+  return null;
+}
+function textOrNull(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed === "" ? null : trimmed;
+}
+
+// src/subscriber-mapping.ts
+function formatCustomerNumber(prefix, sequence) {
+  return `${prefix}${sequence}`;
+}
+function toSubscriberRecord(row, tenantId) {
+  return {
+    id: row.id,
+    customerNumber: formatCustomerNumber(row.customerNumberPrefix, row.customerSequence),
+    legalName: row.legalName,
+    addressLine1: row.addressLine1,
+    addressLine2: row.addressLine2,
+    postalCode: row.postalCode,
+    city: row.city,
+    country: row.country,
+    vatId: row.vatId,
+    taxNumber: row.taxNumber,
+    invoiceEmail: row.invoiceEmail,
+    tenantId,
+    migrated: row.migrated,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt
+  };
+}
+function toSubscriberCorrectionRecord(row) {
+  return {
+    id: row.id,
+    subscriberId: row.subscriberId,
+    previous: toIdentityValues(row.previous),
+    corrected: toIdentityValues(row.corrected),
+    reason: row.reason,
+    correctedBy: row.correctedBy,
+    correctedAt: row.correctedAt
+  };
+}
+function identityCorrectionDelta(current, corrected) {
+  const previous = {};
+  const next = {};
+  for (const field of LEGAL_IDENTITY_FIELDS) {
+    const value = corrected[field];
+    if (value === void 0 || value === current[field]) continue;
+    previous[field] = current[field];
+    next[field] = value;
+  }
+  return {
+    previous,
+    corrected: next
+  };
+}
+function contractPartiesOf(subscriber, issuer) {
+  const party = {
+    customerNumber: subscriber.customerNumber,
+    legalName: subscriber.legalName,
+    vatId: subscriber.vatId,
+    taxNumber: subscriber.taxNumber,
+    addressLine1: subscriber.addressLine1,
+    addressLine2: subscriber.addressLine2,
+    postalCode: subscriber.postalCode,
+    city: subscriber.city,
+    country: subscriber.country
+  };
+  return {
+    subscriberId: subscriber.id,
+    subscriber: party,
+    issuer: issuer ? issuerPartyOf(issuer) : null
+  };
+}
+function issuerPartyOf(issuer) {
+  const identity = issuerIdentityOf(issuer);
+  return {
+    legalName: identity?.legalName ?? "",
+    vatId: identity?.vatId ?? null,
+    taxNumber: identity?.taxNumber ?? null,
+    // Settled like the three above rather than copied verbatim: one copy
+    // whose halves were settled differently is a row that reads two ways,
+    // and a city written with a trailing space is not another city.
+    addressLine1: settledText(issuer.addressLine1),
+    addressLine2: settledText(issuer.addressLine2),
+    postalCode: settledText(issuer.postalCode),
+    city: settledText(issuer.city),
+    country: settledText(issuer.country)
+  };
+}
+function settledText(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed === "" ? null : trimmed;
+}
+function subscriberFromRegistration(pending) {
+  return {
+    legalName: pending.tenantName,
+    invoiceEmail: pending.email,
+    addressLine1: pending.addressLine1,
+    addressLine2: pending.addressLine2,
+    postalCode: pending.postalCode,
+    city: pending.city,
+    country: pending.country,
+    vatId: pending.vatId,
+    taxNumber: pending.taxNumber
+  };
+}
+function toIdentityValues(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return {};
+  const source = value;
+  const values = {};
+  for (const field of LEGAL_IDENTITY_FIELDS) {
+    if (!Object.prototype.hasOwnProperty.call(source, field)) continue;
+    const entry = source[field];
+    values[field] = typeof entry === "string" ? entry : null;
+  }
+  return values;
+}
+
+// src/subscriber-payment-method-mapping.ts
+var PAYMENT_METHOD_TYPES = ["card", "sepa_debit"];
+var STATUSES = ["ACTIVE", "REPLACED"];
+function toSubscriberPaymentMethodRecord(row) {
+  return {
+    id: row.id,
+    subscriberId: row.subscriberId,
+    gatewayAccount: row.gatewayAccount,
+    provider: row.provider,
+    customerRef: row.customerRef,
+    paymentMethodRef: row.paymentMethodRef,
+    type: oneOf(PAYMENT_METHOD_TYPES, row.type, "type", row.id),
+    brand: row.brand,
+    last4: row.last4,
+    expiryMonth: row.expiryMonth,
+    expiryYear: row.expiryYear,
+    country: row.country,
+    bankCode: row.bankCode,
+    mandateReference: row.mandateReference,
+    status: oneOf(STATUSES, row.status, "status", row.id),
+    confirmedAt: row.confirmedAt,
+    replacedAt: row.replacedAt,
+    createdAt: row.createdAt
+  };
+}
+function subscriberPaymentMethodColumns(data) {
+  return {
+    subscriberId: data.subscriberId,
+    gatewayAccount: data.gatewayAccount,
+    provider: data.provider,
+    customerRef: data.customerRef,
+    paymentMethodRef: data.paymentMethodRef,
+    type: data.type,
+    brand: data.brand,
+    last4: data.last4,
+    expiryMonth: data.expiryMonth,
+    expiryYear: data.expiryYear,
+    country: data.country,
+    bankCode: data.bankCode,
+    mandateReference: data.mandateReference,
+    confirmedAt: data.confirmedAt
+  };
+}
+function oneOf(allowed, value, column, id) {
+  const match = allowed.find((entry) => entry === value);
+  if (match === void 0) {
+    throw new Error(
+      `subscriber_payment_methods row '${id}' holds ${column} '${value}', which is none of ${allowed.join(", ")}.`
+    );
+  }
+  return match;
+}
+var FOREIGN_PAYMENT_METHOD_REFERENCE = "FOREIGN_PAYMENT_METHOD_REFERENCE";
+var ForeignPaymentMethodReferenceError = class extends Error {
+  constructor(gatewayAccount, paymentMethodRef) {
+    super(
+      `Payment method '${paymentMethodRef}' of account '${gatewayAccount}' belongs to another subscriber. A reference belongs to exactly one, so it is not handed out.`
+    );
+    this.gatewayAccount = gatewayAccount;
+    this.paymentMethodRef = paymentMethodRef;
+    this.name = "ForeignPaymentMethodReferenceError";
+  }
+  gatewayAccount;
+  paymentMethodRef;
+  code = FOREIGN_PAYMENT_METHOD_REFERENCE;
+};
+function isForeignPaymentMethodReferenceError(error) {
+  return error instanceof Error && error.code === FOREIGN_PAYMENT_METHOD_REFERENCE;
+}
+function refuseForeignPaymentMethodReference(recorded, subscriberId) {
+  if (recorded.subscriberId === subscriberId) return;
+  throw new ForeignPaymentMethodReferenceError(
+    recorded.gatewayAccount,
+    recorded.paymentMethodRef
+  );
+}
+
+// src/subscription-contract-mapping.ts
+function toSubscriptionContractRecord(row, lineItems) {
+  return {
+    id: row.id,
+    tenantId: row.tenantId,
+    subscriberId: row.subscriberId,
+    subscriber: toSubscriberParty(row.subscriberSnapshot),
+    issuer: isPlainObject2(row.issuerSnapshot) ? toIssuerParty(row.issuerSnapshot) : null,
+    partiesMigrated: row.partiesMigrated,
+    status: row.status,
+    effectiveFrom: row.effectiveFrom,
+    effectiveUntil: row.effectiveUntil,
+    originalOfferId: row.originalOfferId,
+    originalPlanVersionId: row.originalPlanVersionId,
+    originalBundleVersionIds: toStringArray(row.originalBundleVersionIds),
+    entitlementSnapshot: isPlainObject2(row.entitlementSnapshot) ? row.entitlementSnapshot : null,
+    priceSnapshot: row.priceSnapshot,
+    promotionSnapshots: toUnknownArray(row.promotionSnapshots),
+    promoCodeSnapshots: toUnknownArray(row.promoCodeSnapshots),
+    termsSnapshot: toRecordOrNull(row.termsSnapshot),
+    lineItems: lineItems.map(toContractLineItemRecord),
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt
+  };
+}
+function toContractLineItemRecord(row) {
+  return {
+    id: row.id,
+    contractId: row.contractId,
+    kind: row.kind,
+    sourceKey: row.sourceKey,
+    sourceVersionId: row.sourceVersionId,
+    titleSnapshot: row.titleSnapshot,
+    descriptionSnapshot: row.descriptionSnapshot,
+    quantity: row.quantity,
+    unit: row.unit,
+    priceNet: Number(row.priceNet),
+    priceGross: Number(row.priceGross),
+    billingCycle: row.billingCycle,
+    currency: row.currency,
+    taxRate: Number(row.taxRate),
+    taxAmount: Number(row.taxAmount),
+    minimumTermUntil: row.minimumTermUntil,
+    featuresSnapshot: toStringArray(row.featuresSnapshot),
+    quotaEffectsSnapshot: toQuotaEffects2(row.quotaEffectsSnapshot),
+    metadata: toRecordOrNull(row.metadata),
+    createdAt: row.createdAt
+  };
+}
+function toSubscriberParty(value) {
+  const source = isPlainObject2(value) ? value : {};
+  return {
+    customerNumber: stringOr(source.customerNumber, ""),
+    ...toIssuerParty(source)
+  };
+}
+function toRunningContractIssuer(row) {
+  const issuer = isPlainObject2(row.issuerSnapshot) ? row.issuerSnapshot : null;
+  return {
+    id: row.id,
+    tenantId: row.tenantId,
+    issuerLegalName: issuer ? stringOrNull(issuer.legalName) : null,
+    effectiveFrom: row.effectiveFrom
+  };
+}
+function toIssuerParty(value) {
+  const source = value;
+  return {
+    legalName: stringOr(source.legalName, ""),
+    vatId: stringOrNull(source.vatId),
+    taxNumber: stringOrNull(source.taxNumber),
+    addressLine1: stringOrNull(source.addressLine1),
+    addressLine2: stringOrNull(source.addressLine2),
+    postalCode: stringOrNull(source.postalCode),
+    city: stringOrNull(source.city),
+    country: stringOrNull(source.country)
+  };
+}
+function stringOr(value, fallback) {
+  return typeof value === "string" ? value : fallback;
+}
+function stringOrNull(value) {
+  return typeof value === "string" ? value : null;
+}
+function isPlainObject2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function toUnknownArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+function toRecordOrNull(value) {
+  return isPlainObject2(value) ? value : null;
+}
+function toStringArray(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((entry) => typeof entry === "string");
+}
+function toQuotaEffects2(value) {
+  return isPlainObject2(value) ? readQuotaRecord(value) : {};
+}
+
+// src/subscription-contract.types.ts
+var BUNDLE_PRICE_LOOKUP_LIMIT = 200;
+var ACTIVE_SUBSCRIPTION_CONTRACT_STATUSES = [
+  "active",
+  "scheduled"
+];
+
 // src/version-editability.ts
 function isVersionEditable(v, now = /* @__PURE__ */ new Date()) {
   if (v.publishedAt === null) {
@@ -611,6 +1415,17 @@ function isVersionEditable(v, now = /* @__PURE__ */ new Date()) {
   return { editable: true, reason: "pre-active" };
 }
 
+// src/recommended-plan.ts
+function keepOneRecommended(plans, inRequestedLocale) {
+  const recommended = plans.filter((plan) => plan.highlight);
+  if (recommended.length === 0) return null;
+  const winner = recommended.find((plan) => inRequestedLocale.has(plan.planKey)) ?? recommended[0];
+  for (const plan of recommended) {
+    if (plan !== winner) plan.highlight = false;
+  }
+  return winner;
+}
+
 // src/error-messages.ts
 var ERROR_MESSAGES_EN = {
   // ── setup ──
@@ -624,6 +1439,7 @@ var ERROR_MESSAGES_EN = {
   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.",
@@ -655,6 +1471,8 @@ var ERROR_MESSAGES_EN = {
   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",
@@ -668,22 +1486,28 @@ var ERROR_MESSAGES_EN = {
   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 in project '{projectKey}'",
-  QUOTA_NOT_FOUND: "Quota '{quotaKey}' not found in project '{projectKey}'",
+  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 in project '{projectKey}'",
-  BUNDLE_ALREADY_EXISTS: "Bundle '{bundleKey}' already exists in project '{projectKey}'",
+  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.",
@@ -692,9 +1516,25 @@ var ERROR_MESSAGES_EN = {
   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 ({projectKey})',
-  PLAN_NOT_SELF_SERVICE: "{planKey} is not activated via self-service.",
+  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.",
@@ -704,7 +1544,7 @@ var ERROR_MESSAGES_EN = {
   // ── 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 \u2014 it cannot be soft-deleted. Pause it instead.",
+  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.",
@@ -722,18 +1562,39 @@ var ERROR_MESSAGES_EN = {
   CHECKOUT_OFFER_BUNDLE_LINE_ITEMS_REQUIRED: "Every selected bundle version requires a frozen bundle line item.",
   CHECKOUT_OFFER_BUNDLE_VERSION_NOT_BOOKABLE: "At least one bundle version from the checkout offer is no longer bookable.",
   CHECKOUT_OFFER_FEATURE_DEPENDENCY_UNSATISFIED: "The selected plan does not cover all feature dependencies: [{missingRequires}] are missing from the plan + selected bundles.",
+  CHECKOUT_OFFER_PLAN_NOT_OFFERED: "Plan '{planKey}' is not offered with a {billingCycle} price at the moment.",
+  CHECKOUT_OFFER_BUNDLE_NOT_OFFERED: "Bundle version '{bundleVersionId}' cannot be added to this offer ({reason}).",
+  CHECKOUT_OFFER_PROMO_CODE_NOT_ACCEPTED: "The promo code cannot be applied to this offer ({reason}).",
+  CHECKOUT_OFFER_PRICE_NOT_CURRENT: "The prices of checkout offer '{offerId}' no longer match the catalogue; create a new offer.",
   SUBSCRIPTION_CONTRACT_LINE_ITEMS_REQUIRED: "A subscription contract requires at least one line item.",
   SUBSCRIPTION_CONTRACT_PLAN_LINE_ITEM_REQUIRED: "A subscription contract requires exactly one plan base item.",
   SUBSCRIPTION_CONTRACT_INVALID_DATE: "{field} must be a valid date.",
   SUBSCRIPTION_CONTRACT_INVALID_WINDOW: "effectiveUntil must be after effectiveFrom.",
+  SUBSCRIPTION_CONTRACT_LINE_ITEM_TAX_MISMATCH: "A line item's taxAmount must be exactly priceGross minus priceNet.",
+  SUBSCRIPTION_CONTRACT_TAX_RATE_NOT_PERCENT: "A subscription contract states a tax rate of {taxRate} at {field}, which is not a percentage: a rate lies from 0 to 100, and a value between 0 and 1 is refused as a fraction.",
   SUBSCRIPTION_CONTRACT_TERMINATION_BEFORE_START: "effectiveUntil must be after the effectiveFrom of the contract.",
+  SUBSCRIPTION_CONTRACT_LINE_ITEM_CURRENCY_MISMATCH: "A line item must be booked in the currency its contract was priced in.",
+  SUBSCRIPTION_CONTRACT_LINES_DO_NOT_ADD_UP: "The line items of a subscription contract add up to {lines} for {field}, but the contract states {stated}.",
+  SUBSCRIPTION_CONTRACT_DISCOUNT_NEGATIVE: "A subscription contract states a discount of {amount} at {field}; a discount takes money off and is never negative.",
   CHECKOUT_OFFER_NOT_FOUND: "CheckoutOffer '{offerId}' not found",
   CHECKOUT_OFFER_EXPIRED: "Checkout offer '{offerId}' has expired and cannot be {action}",
   CHECKOUT_OFFER_ALREADY_CONSUMED: "Checkout offer '{offerId}' has already been consumed and cannot be {action}",
   CHECKOUT_OFFER_NOT_CONSUMED: "CheckoutOffer '{offerId}' must be consumed before the contract is created",
+  CHECKOUT_OFFER_CHANGED: "Checkout offer '{offerId}' changed while it was being concluded. Load it again.",
   SUBSCRIPTION_CONTRACT_NOT_FOUND: "SubscriptionContract '{contractId}' not found",
   NO_ACTIVE_SUBSCRIPTION_CONTRACT: "No active subscription contract for tenant {tenantId}",
   SUBSCRIPTION_CONTRACT_ALREADY_CLOSED: "SubscriptionContract '{contractId}' is already closed",
+  // ── subscriber ──
+  SUBSCRIBER_REQUIRED: "Tenant '{tenantId}' has no subscriber. Nothing is agreed or charged without the party to it: create the tenant's subscriber first.",
+  SUBSCRIBER_ALREADY_EXISTS: "Tenant '{tenantId}' already has a subscriber.",
+  SUBSCRIBER_NOT_FOUND: "Subscriber '{subscriberId}' not found",
+  SUBSCRIBER_LEGAL_NAME_REQUIRED: "A subscriber needs its legal name.",
+  SUBSCRIBER_DETAIL_INVALID: "The subscriber's {field} is not valid.",
+  SUBSCRIBER_IDENTITY_NOT_A_CONTACT: "{field} is part of the subscriber's legal identity and changes only as a correction, with a reason.",
+  SUBSCRIBER_CORRECTION_REASON_REQUIRED: "A correction of the legal identity needs a reason.",
+  SUBSCRIBER_CORRECTION_ACTOR_REQUIRED: "A correction of the legal identity has to say who makes it.",
+  SUBSCRIBER_CORRECTION_CHANGES_NOTHING: "The correction changes nothing: every value it names is already recorded.",
+  SUBSCRIBER_TAKEOVER_IS_A_TRANSFER: "Another legal entity taking over a subscriber is a transfer, not a correction, and cannot be recorded as an edit.",
   // ── registration ──
   PENDING_REGISTRATION_NOT_FOUND: "This registration could not be found. It may have already been completed or discarded.",
   PENDING_REGISTRATION_EXPIRED: "This registration has expired. Please start again.",
@@ -749,8 +1610,15 @@ var ERROR_MESSAGES_EN = {
   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.",
   // ── entitlement (code lives in upsell.types.ts) ──
-  [FEATURE_NOT_LICENSED]: "Feature {featureKeys} is not included in the current plan."
+  [FEATURE_NOT_LICENSED]: "Feature {featureKeys} is not included in the current plan.",
+  // ── settings ──
+  SETTINGS_CHANGE_NOT_FOUND: "No recorded settings change has this id."
 };
 function formatErrorMessage(template, params = {}) {
   return template.replace(/\{(\w+)\}/g, (match, name) => {
@@ -781,6 +1649,7 @@ var ERROR_MESSAGES_DE = {
   NO_TENANT_ASSIGNED: "Kein Mandant zugeordnet",
   TENANT_CONTEXT_MISSING: "Am Request wurde keine Mandanten-ID gefunden",
   TENANT_ADMIN_REQUIRED: "Diese Aktion erfordert die Rolle TENANT_ADMIN.",
+  BILLING_PERMISSION_REQUIRED: "Dieser Teil der Abrechnung erfordert die Abrechnungs-Berechtigung.",
   SUPER_ADMIN_REQUIRED: "Nur die Rolle SUPER_ADMIN ist zugelassen",
   MFA_NOT_SET_UP: "Richte MFA zuerst \xFCber die CLI ein.",
   MFA_REQUIRED: "TOTP-Code im Header X-Mfa-Code erforderlich.",
@@ -812,6 +1681,8 @@ var ERROR_MESSAGES_DE = {
   BUNDLE_VERSION_SUPERSEDED: "BundleVersion '{bundleVersionId}' wurde durch eine neuere Version abgel\xF6st.",
   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",
@@ -825,22 +1696,28 @@ var ERROR_MESSAGES_DE = {
   PLAN_VERSION_NOT_FOUND: "PlanVersion '{versionId}' nicht gefunden",
   BUNDLE_NOT_FOUND: "Bundle '{bundleId}' nicht gefunden",
   BUNDLE_VERSION_NOT_FOUND: "BundleVersion '{bundleVersionId}' nicht gefunden",
-  FEATURE_NOT_FOUND: "Feature '{featureKey}' im Projekt '{projectKey}' nicht gefunden",
-  QUOTA_NOT_FOUND: "Quota '{quotaKey}' im Projekt '{projectKey}' nicht gefunden",
+  FEATURE_NOT_FOUND: "Feature '{featureKey}' nicht gefunden",
+  QUOTA_NOT_FOUND: "Quota '{quotaKey}' nicht gefunden",
   PROMOTION_NOT_FOUND: "Promotion '{promotionId}' nicht gefunden",
+  PROMOTION_VALUE_INVALID: "Der Wert einer Aktion vom Typ '{type}' passt nicht zu ihrem Typ: ein Prozentsatz \xFCber 0 und h\xF6chstens 100, ein Betrag \xFCber 0, ein Einf\xFChrungspreis ab 0 f\xFCr eine ganze Zahl von Monaten oder eine ganze Zahl von Gratismonaten.",
   MARKETING_PROJECTION_NOT_FOUND: "MarketingProjection '{projectionId}' nicht gefunden",
-  PLAN_ALREADY_EXISTS: "Plan '{planKey}' gibt es im Projekt '{projectKey}' bereits",
-  BUNDLE_ALREADY_EXISTS: "Bundle '{bundleKey}' gibt es im Projekt '{projectKey}' bereits",
+  PLAN_ALREADY_EXISTS: "Plan '{planKey}' gibt es bereits",
+  BUNDLE_ALREADY_EXISTS: "Bundle '{bundleKey}' gibt es bereits",
   MARKETING_PROJECTION_ALREADY_EXISTS: "F\xFCr {targetType}/{targetVersionId}/{locale} gibt es bereits eine Marketing-Projektion \u2014 bearbeite sie per PATCH",
   PLAN_DRAFT_ALREADY_EXISTS: "Plan '{planKey}' hat bereits die Entwurfsversion v{draftVersion}; ver\xF6ffentliche oder verwirf sie zuerst",
   BUNDLE_DRAFT_ALREADY_EXISTS: "Bundle '{bundleKey}' hat bereits die Entwurfsversion v{draftVersion}; ver\xF6ffentliche oder verwirf sie zuerst",
   QUOTA_NOT_IN_DISCOVERY_SNAPSHOT: "Quota '{quotaKey}' steht nicht im Discovery-Snapshot \u2014 eine Quota, die im Code nicht deklariert ist, l\xE4sst sich nicht freigeben",
   DISCOVERY_STATUS_TRANSITION_INVALID: "Der \xDCbergang '{from}' \u2192 '{to}' ist nicht erlaubt",
   DISCOVERY_NOT_INITIALIZED: "Die Freigabe braucht einen Discovery-Snapshot \u2014 Discovery ist nicht initialisiert (#25)",
+  // ── catalogue import ──
+  PLAN_CATALOG_UNREADABLE: "Diese Datei ist kein Plankatalog \u2014 sie lie\xDF sich nicht als einer lesen. Pr\xFCfe, ob es die YAML-Datei ist, in der deine App ihre Pl\xE4ne deklariert.",
+  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_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.",
   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.",
@@ -849,9 +1726,25 @@ var ERROR_MESSAGES_DE = {
   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.",
-  PLAN_NOT_IN_CATALOG: 'Plan "{planKey}" steht nicht im Katalog ({projectKey})',
-  PLAN_NOT_SELF_SERVICE: "{planKey} wird nicht per Self-Service freigeschaltet.",
+  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.",
   PLAN_CHANGE_BLOCKED: "W\xE4hrend des Onboardings ist ein Planwechsel gesperrt.",
+  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.",
+  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.",
+  FEATURE_LOST: "Beim Wechsel verlieren Sie den Zugriff auf eine Funktion. Vorhandene Daten bleiben erhalten und werden nie gel\xF6scht \u2014 ein sp\xE4teres Upgrade schaltet sie wieder frei.",
+  FEATURES_LOST: "Beim Wechsel verlieren Sie den Zugriff auf {count} Funktionen. Vorhandene Daten bleiben erhalten und werden nie gel\xF6scht \u2014 ein sp\xE4teres Upgrade schaltet sie wieder frei.",
+  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.",
+  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.",
@@ -861,7 +1754,7 @@ var ERROR_MESSAGES_DE = {
   // ── promo ──
   PROMO_CODE_NOT_FOUND: "Code nicht gefunden",
   PROMO_CODE_ALREADY_EXISTS: "Diesen Code gibt es bereits.",
-  PROMO_CODE_HAS_REDEMPTIONS: "Der Code wurde bereits eingel\xF6st \u2014 er l\xE4sst sich nicht per Soft-Delete entfernen. Pausiere ihn stattdessen.",
+  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).',
   PROMO_PERCENT_OUT_OF_RANGE: "Der Prozentwert muss zwischen 0 und 100 liegen.",
@@ -879,18 +1772,39 @@ var ERROR_MESSAGES_DE = {
   CHECKOUT_OFFER_BUNDLE_LINE_ITEMS_REQUIRED: "Jede gew\xE4hlte Bundle-Version braucht eine eingefrorene Bundle-Position.",
   CHECKOUT_OFFER_BUNDLE_VERSION_NOT_BOOKABLE: "Mindestens eine Bundle-Version aus dem Checkout-Angebot ist nicht mehr buchbar.",
   CHECKOUT_OFFER_FEATURE_DEPENDENCY_UNSATISFIED: "Der gew\xE4hlte Plan deckt nicht alle Feature-Abh\xE4ngigkeiten ab: [{missingRequires}] fehlen in Plan und gew\xE4hlten Bundles.",
+  CHECKOUT_OFFER_PLAN_NOT_OFFERED: "Plan '{planKey}' wird derzeit nicht mit einem Preis f\xFCr den Rhythmus {billingCycle} angeboten.",
+  CHECKOUT_OFFER_BUNDLE_NOT_OFFERED: "Bundle-Version '{bundleVersionId}' kann diesem Angebot nicht hinzugef\xFCgt werden ({reason}).",
+  CHECKOUT_OFFER_PROMO_CODE_NOT_ACCEPTED: "Der Rabattcode kann auf dieses Angebot nicht angewendet werden ({reason}).",
+  CHECKOUT_OFFER_PRICE_NOT_CURRENT: "Die Preise des Angebots '{offerId}' stimmen nicht mehr mit dem Katalog \xFCberein; bitte ein neues Angebot erstellen.",
   SUBSCRIPTION_CONTRACT_LINE_ITEMS_REQUIRED: "Ein Abo-Vertrag braucht mindestens eine Position.",
   SUBSCRIPTION_CONTRACT_PLAN_LINE_ITEM_REQUIRED: "Ein Abo-Vertrag braucht genau eine Plan-Grundposition.",
   SUBSCRIPTION_CONTRACT_INVALID_DATE: "{field} muss ein g\xFCltiges Datum sein.",
   SUBSCRIPTION_CONTRACT_INVALID_WINDOW: "effectiveUntil muss nach effectiveFrom liegen.",
+  SUBSCRIPTION_CONTRACT_LINE_ITEM_TAX_MISMATCH: "taxAmount einer Position muss exakt priceGross minus priceNet sein.",
+  SUBSCRIPTION_CONTRACT_TAX_RATE_NOT_PERCENT: "Ein Abo-Vertrag nennt bei {field} einen Steuersatz von {taxRate}, der kein Prozentsatz ist: Ein Satz liegt zwischen 0 und 100, und ein Wert zwischen 0 und 1 wird als Bruch abgelehnt.",
+  SUBSCRIPTION_CONTRACT_LINE_ITEM_CURRENCY_MISMATCH: "Eine Position muss in der W\xE4hrung gebucht sein, in der ihr Vertrag bepreist ist.",
+  SUBSCRIPTION_CONTRACT_LINES_DO_NOT_ADD_UP: "Die Positionen eines Abo-Vertrags ergeben {lines} f\xFCr {field}, der Vertrag nennt aber {stated}.",
+  SUBSCRIPTION_CONTRACT_DISCOUNT_NEGATIVE: "Ein Abo-Vertrag nennt bei {field} einen Rabatt von {amount}; ein Rabatt zieht Geld ab und ist nie negativ.",
   SUBSCRIPTION_CONTRACT_TERMINATION_BEFORE_START: "effectiveUntil muss nach dem effectiveFrom des Vertrags liegen.",
   CHECKOUT_OFFER_NOT_FOUND: "CheckoutOffer '{offerId}' nicht gefunden",
   CHECKOUT_OFFER_EXPIRED: "Checkout-Angebot '{offerId}' ist abgelaufen \u2014 '{action}' ist nicht mehr m\xF6glich",
   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.",
   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",
+  // ── subscriber ──
+  SUBSCRIBER_REQUIRED: "Mandant '{tenantId}' hat keinen Vertragspartner. Ohne ihn wird nichts vereinbart oder berechnet: Zuerst muss der Vertragspartner des Mandanten angelegt werden.",
+  SUBSCRIBER_ALREADY_EXISTS: "Mandant '{tenantId}' hat bereits einen Vertragspartner.",
+  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_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.",
   // ── 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.",
@@ -906,52 +1820,105 @@ var ERROR_MESSAGES_DE = {
   PLAN_NOT_AVAILABLE: "Dieser Plan steht nicht zur Verf\xFCgung.",
   PLAN_NOT_SELECTED: "Bitte w\xE4hle zuerst einen Plan aus.",
   MODEL_NOT_AVAILABLE: "Diese Option steht nicht zur Verf\xFCgung.",
+  // ── payments ──
+  PAYMENTS_NOT_CONFIGURED: "Zahlungsmethoden k\xF6nnen hier noch nicht hinterlegt werden.",
+  PAYMENT_GATEWAY_ACCOUNT_UNKNOWN: "Unter '{account}' ist kein Konto eines Zahlungsanbieters eingerichtet.",
+  PAYMENT_CALLBACK_REJECTED: "Die R\xFCckmeldung des Zahlungsanbieters lie\xDF sich nicht pr\xFCfen.",
+  PAYMENT_RETURN_URL_NOT_ALLOWED: "Die {field} f\xFChrt auf eine Seite, zu der diese Installation nicht zur\xFCckleitet.",
   // ── entitlement (code lives in upsell.types.ts) ──
-  [FEATURE_NOT_LICENSED]: "Das Feature {featureKeys} ist im aktuellen Plan nicht enthalten."
+  [FEATURE_NOT_LICENSED]: "Das Feature {featureKeys} ist im aktuellen Plan nicht enthalten.",
+  // ── settings ──
+  SETTINGS_CHANGE_NOT_FOUND: "Keine aufgezeichnete Einstellungs\xE4nderung hat diese ID."
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ACTIVE_SUBSCRIPTION_CONTRACT_STATUSES,
   AUTH_ERROR_CODES,
   BILLING_ERROR_CODES,
+  BUNDLE_PRICE_LOOKUP_LIMIT,
+  CATALOGUE_KEYS,
   CATALOG_ERROR_CODES,
   CONTRACT_ERROR_CODES,
   ERROR_MESSAGES_DE,
   ERROR_MESSAGES_EN,
   FEATURE_NOT_LICENSED,
+  ForeignPaymentMethodReferenceError,
+  LEGAL_IDENTITY_FIELDS,
+  MARKETING_PRIORITY_MAX,
+  MARKETING_PRIORITY_MIN,
   OTP_RATE_LIMIT_MAX_SENDS,
   OTP_RATE_LIMIT_WINDOW_MINUTES,
   OTP_TTL_MINUTES,
   OTP_VERIFY_MAX_ATTEMPTS,
   PASSWORD_RESET_TTL_MINUTES,
+  PAYMENT_ERROR_CODES,
+  PAYMENT_METHOD_TYPES,
   PENDING_CHECKOUT_TTL_DAYS,
   PENDING_EMAIL_TTL_HOURS,
   PENDING_ONBOARDING_TTL_DAYS,
   PLATFORM_ERROR_CODES,
   PROMO_ERROR_CODES,
+  PaymentCallbackRejectedError,
   PersistenceCapabilityError,
   PlatformUserExistsError,
   REGISTRATION_ERROR_CODES,
   REGISTRATION_RESUME_TTL_MINUTES,
   REGISTRATION_STEP_BY_STATUS,
+  SETTINGS_ERROR_CODES,
   SETUP_ERROR_CODES,
+  SUBSCRIBER_ERROR_CODES,
   applyPromo,
   assertPersistenceCapabilities,
   buildActivePlanVersionWhere,
   buildActiveVersionWhere,
   buildFeatureRequiresIndex,
+  bundleDraftDefaults,
+  bundleStemDefaults,
+  canonicalJson,
   classifyBundleVersionDiff,
+  classifyIssuerChange,
   classifyPlanDiff,
   collectUnsatisfiedRequires,
+  contractPartiesOf,
   coverageExcludingSelf,
+  definedFields,
+  diffSettings,
+  formatCustomerNumber,
   formatErrorMessage,
+  identityCorrectionDelta,
   isBundleRedundant,
+  isForeignPaymentMethodReferenceError,
+  isPaymentCallbackRejectedError,
   isPlatformUserExistsError,
   isVersionEditable,
+  issuerIdentityOf,
+  keepOneRecommended,
   missingRequiresFor,
+  movedIdentityFields,
   pickActivePromo,
+  planCatalogSettingsOf,
+  previousUtcDay,
   promoStatus,
+  promotionOnPrice,
+  readQuotaRecord,
+  readQuotaValue,
+  recordedIssuerIdentity,
+  refuseForeignPaymentMethodReference,
   resolveBundleAvailability,
   resolveErrorMessage,
+  sameLegalIdentity,
   selectChargeableBundles,
-  startOfUtcDay
+  settingsSubtreeOf,
+  startOfUtcDay,
+  subscriberFromRegistration,
+  subscriberPaymentMethodColumns,
+  toBundleStemRow,
+  toContractLineItemRecord,
+  toPlanRow,
+  toPlanVersionRow,
+  toRunningContractIssuer,
+  toSubscriberCorrectionRecord,
+  toSubscriberPaymentMethodRecord,
+  toSubscriberRecord,
+  toSubscriptionContractRecord
 });