@saasicat/nest 0.18.1 → 0.21.0

package/dist/{chunk-GLLCB4BP.js → chunk-4O6R6ARQ.js}

@@ -8,13 +8,16 @@ import {
   PROMO_SUBSCRIPTION_LOOKUP_TOKEN,
   PROMO_TRANSACTION_RUNNER_TOKEN,
   PromoCodesService
-} from "./chunk-E7AJ42AB.js";
+} from "./chunk-VQQWF7MW.js";
 import {
   AdminAuditService
 } from "./chunk-E56W4U2P.js";
 import {
   SaaSiCatPublicRoute
 } from "./chunk-YSC46BGM.js";
+import {
+  codedError
+} from "./chunk-EBJJNTW6.js";
 import {
   asProvider
 } from "./chunk-SABTXESR.js";
@@ -58,7 +61,7 @@ var PromoCodeExpirer = class _PromoCodeExpirer {
     const codes = await this.promoRepo.expireDueCodes(now);
     const redemptions = await this.redemptionRepo.expireDueRedemptions(now);
     if (codes > 0 || redemptions > 0) {
-      this.logger.log(`PromoCodeExpirer: ${codes} Codes, ${redemptions} Redemptions abgelaufen.`);
+      this.logger.log(`PromoCodeExpirer: ${codes} Codes, ${redemptions} redemptions expired.`);
     }
   }
 };
@@ -84,6 +87,7 @@ PromoCodeExpirer = _ts_decorate([
 
 // src/promo/rate-limit.guard.ts
 import { HttpException, HttpStatus, Injectable as Injectable2 } from "@nestjs/common";
+import { REGISTRATION_ERROR_CODES } from "@saasicat/types";
 function _ts_decorate2(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -95,6 +99,18 @@ var IP_WINDOW_MS = 6e4;
 var IP_LIMIT = 20;
 var SESSION_WINDOW_MS = 60 * 6e4;
 var SESSION_LIMIT = 50;
+function rateLimited(windowMs) {
+  return new HttpException({
+    ...codedError(REGISTRATION_ERROR_CODES.RATE_LIMITED, {
+      retryAfterSeconds: Math.ceil(windowMs / 1e3)
+    }),
+    retryAfterSeconds: Math.ceil(windowMs / 1e3),
+    valid: false,
+    // Superseded by `code` — kept until all consumers read `code`.
+    reason: "RATE_LIMITED"
+  }, HttpStatus.TOO_MANY_REQUESTS);
+}
+__name(rateLimited, "rateLimited");
 var PromoCodeRateLimitGuard = class {
   static {
     __name(this, "PromoCodeRateLimitGuard");
@@ -106,16 +122,10 @@ var PromoCodeRateLimitGuard = class {
     const ipKey = ipFingerprint(req);
     const sessionKey = req.user?.id ?? null;
     if (this.exceeded(this.ipBuckets, ipKey, IP_WINDOW_MS, IP_LIMIT)) {
-      throw new HttpException({
-        valid: false,
-        reason: "RATE_LIMITED"
-      }, HttpStatus.TOO_MANY_REQUESTS);
+      throw rateLimited(IP_WINDOW_MS);
     }
     if (sessionKey && this.exceeded(this.sessionBuckets, sessionKey, SESSION_WINDOW_MS, SESSION_LIMIT)) {
-      throw new HttpException({
-        valid: false,
-        reason: "RATE_LIMITED"
-      }, HttpStatus.TOO_MANY_REQUESTS);
+      throw rateLimited(SESSION_WINDOW_MS);
     }
     return true;
   }
@@ -179,21 +189,21 @@ var PreviewPromoCodeDto = class {
 _ts_decorate3([
   IsString(),
   Matches(CODE_PATTERN, {
-    message: 'code muss aus A\u2013Z, 0\u20139, "-" und "_" bestehen (4\u201332 Zeichen)'
+    message: 'code must consist of A\u2013Z, 0\u20139, "-" and "_" (4\u201332 characters)'
   }),
   _ts_metadata2("design:type", String)
 ], PreviewPromoCodeDto.prototype, "code", void 0);
 _ts_decorate3([
   IsString(),
   Matches(PLAN_OR_CYCLE_PATTERN, {
-    message: "plan muss SCREAMING_SNAKE_CASE sein"
+    message: "plan must be SCREAMING_SNAKE_CASE"
   }),
   _ts_metadata2("design:type", String)
 ], PreviewPromoCodeDto.prototype, "plan", void 0);
 _ts_decorate3([
   IsString(),
   Matches(PLAN_OR_CYCLE_PATTERN, {
-    message: "billingCycle muss SCREAMING_SNAKE_CASE sein (z. B. MONTHLY, YEARLY)"
+    message: "billingCycle must be SCREAMING_SNAKE_CASE (e.g. MONTHLY, YEARLY)"
   }),
   _ts_metadata2("design:type", String)
 ], PreviewPromoCodeDto.prototype, "billingCycle", void 0);

package/dist/{chunk-7RRWI5LH.js → chunk-55QGAZRQ.js}

@@ -1,12 +1,12 @@
 import {
   DiscoverySnapshotNotFoundError,
   loadDiscoverySnapshotFromFile
-} from "./chunk-ABB2CRAS.js";
+} from "./chunk-74SCJ4HF.js";
 import {
   ADVISORY_STRICT_MODE_CODES,
   validateBundleDraft,
   validatePlanDraft
-} from "./chunk-P3DP6GJE.js";
+} from "./chunk-GC5AKN44.js";
 import {
   __name
 } from "./chunk-SHUYVCID.js";
@@ -66,9 +66,9 @@ function runPreflight(input) {
 __name(runPreflight, "runPreflight");
 function formatPreflightReport(report) {
   const lines = [];
-  lines.push(`Preflight (Status: ${report.overall.toUpperCase()})`, `  Plans: ${report.counts.planFindings} \xB7 Bundles: ${report.counts.bundleFindings} \xB7 Gesamt: ${report.counts.total}`, "");
+  lines.push(`Preflight (Status: ${report.overall.toUpperCase()})`, `  Plans: ${report.counts.planFindings} \xB7 Bundles: ${report.counts.bundleFindings} \xB7 Total: ${report.counts.total}`, "");
   if (report.findings.length === 0) {
-    lines.push("  \u2713 Keine Strict-Mode-Verst\xF6\xDFe gefunden.");
+    lines.push("  \u2713 No strict-mode violations found.");
     return lines.join("\n");
   }
   let lastEntity = "";
@@ -138,9 +138,9 @@ function validateSeedAgainstSnapshot(input) {
 __name(validateSeedAgainstSnapshot, "validateSeedAgainstSnapshot");
 function formatSeedGateReport(report) {
   const lines = [];
-  lines.push(`Seed-Gate (Status: ${report.overall.toUpperCase()})`, `  Plans: ${report.counts.planFindings} \xB7 Bundles: ${report.counts.bundleFindings} \xB7 Gesamt: ${report.counts.total}`, "");
+  lines.push(`Seed-Gate (Status: ${report.overall.toUpperCase()})`, `  Plans: ${report.counts.planFindings} \xB7 Bundles: ${report.counts.bundleFindings} \xB7 Total: ${report.counts.total}`, "");
   if (report.findings.length === 0) {
-    lines.push("  \u2713 Alle geseedeten Plan-/Bundle-Features sind discovered (und, sofern gepr\xFCft, approved).");
+    lines.push("  \u2713 Every seeded plan/bundle feature is discovered (and approved where checked).");
     return lines.join("\n");
   }
   let lastEntity = "";
@@ -174,10 +174,10 @@ function runSeedGateFromFile(options) {
   } catch (err) {
     if (err instanceof DiscoverySnapshotNotFoundError) {
       if (mode === "blocking") {
-        error(`[seed-gate] FEHLER: Kein Discovery-Snapshot unter ${options.snapshotPath} \u2014 im blocking-Modus Pflicht (Headless-Scan vor dem Seed ausf\xFChren, #23).`);
+        error(`[seed-gate] ERROR: no discovery snapshot at ${options.snapshotPath} \u2014 required in blocking mode (run the headless scan before seeding, #23).`);
         return exit(4);
       }
-      warn(`[seed-gate] Kein Discovery-Snapshot unter ${options.snapshotPath} \u2014 \xFCbersprungen (report-only).`);
+      warn(`[seed-gate] No discovery snapshot at ${options.snapshotPath} \u2014 skipped (report-only).`);
       return null;
     }
     throw err;
@@ -191,10 +191,10 @@ function runSeedGateFromFile(options) {
   log(formatSeedGateReport(report));
   if (report.overall === "error") {
     if (mode === "blocking") {
-      error("[seed-gate] blocking: Verst\xF6\xDFe gefunden \u2014 Seed wird abgebrochen (#23).");
+      error("[seed-gate] blocking: violations found \u2014 aborting the seed (#23).");
       return exit(seedGateExitCode(report));
     }
-    warn("[seed-gate] report-only: Verst\xF6\xDFe gefunden, Seed l\xE4uft trotzdem weiter.");
+    warn("[seed-gate] report-only: violations found, seeding continues anyway.");
   }
   return report;
 }

package/dist/{chunk-Z3FWN3HJ.js → chunk-5ZXBXYXU.js}

@@ -74,7 +74,7 @@ var DiscoveryScanner = class _DiscoveryScanner {
       writeFileSync(path, JSON.stringify(snapshot, null, 2) + "\n", "utf-8");
       this.logger.log(`Discovery snapshot persisted to ${path}`);
     } catch (err) {
-      this.logger.warn(`Discovery snapshot konnte nicht nach ${path} geschrieben werden: ${err.message}`);
+      this.logger.warn(`The discovery snapshot could not be written to ${path}: ${err.message}`);
     }
   }
   /**
@@ -159,7 +159,7 @@ var DiscoveryScanner = class _DiscoveryScanner {
   registerCapability(target, meta, declaredAt) {
     const existing = target.get(meta.capabilityKey);
     if (existing) {
-      this.logger.warn(`Capability '${meta.capabilityKey}' wird an mehreren Stellen deklariert (${existing.declaredAt} und ${declaredAt}); erste Deklaration gewinnt`);
+      this.logger.warn(`Capability '${meta.capabilityKey}' is declared in several places (${existing.declaredAt} and ${declaredAt}); the first declaration wins`);
       return;
     }
     target.set(meta.capabilityKey, {
@@ -180,7 +180,7 @@ var DiscoveryScanner = class _DiscoveryScanner {
   registerQuota(target, opts, declaredAt) {
     const existing = target.get(opts.key);
     if (existing) {
-      this.logger.warn(`Quota '${opts.key}' wird an mehreren Stellen definiert (${existing.declaredAt} und ${declaredAt}); erste Definition gewinnt`);
+      this.logger.warn(`Quota '${opts.key}' is defined in several places (${existing.declaredAt} and ${declaredAt}); the first definition wins`);
       return;
     }
     target.set(opts.key, {

package/dist/{chunk-V34AA7C7.js → chunk-6WL6VQ7Z.js}

@@ -2,7 +2,7 @@ import {
   DISCOVERY_APP_INFO_TOKEN,
   DISCOVERY_SNAPSHOT_PATH_TOKEN,
   DiscoveryScanner
-} from "./chunk-Z3FWN3HJ.js";
+} from "./chunk-5ZXBXYXU.js";
 import {
   DISCOVERY_SNAPSHOT_TOKEN
 } from "./chunk-L4SUWH5B.js";

package/dist/{chunk-ABB2CRAS.js → chunk-74SCJ4HF.js}

@@ -11,7 +11,7 @@ var DiscoverySnapshotNotFoundError = class extends Error {
   }
   path;
   constructor(path) {
-    super(`Discovery-Snapshot-Datei nicht gefunden: ${path}. Booten Sie zuerst die App mit DISCOVERY_SNAPSHOT_PATH oder DiscoveryModule.forRoot({ snapshotPath: '\u2026' }), damit der Scanner die Datei beim OnApplicationBootstrap-Hook schreibt.`), this.path = path;
+    super(`Discovery snapshot file not found: ${path}. Boot the app first with DISCOVERY_SNAPSHOT_PATH or DiscoveryModule.forRoot({ snapshotPath: '\u2026' }) so that the scanner writes the file on the OnApplicationBootstrap hook.`), this.path = path;
     this.name = "DiscoverySnapshotNotFoundError";
   }
 };

package/dist/{chunk-EXOLOJFZ.js → chunk-AGOG5B77.js}

@@ -1,10 +1,13 @@
 import {
   PLAN_CATALOG_TOKEN,
   isFeaturePlannedOnly
-} from "./chunk-R2QOSVAA.js";
+} from "./chunk-DQKCK7DX.js";
 import {
   SUBSCRIPTION_CONTRACT_REPOSITORY_TOKEN
 } from "./chunk-NYLON2VC.js";
+import {
+  codedError
+} from "./chunk-EBJJNTW6.js";
 import {
   ENTITLEMENT_RESOLUTION_CONFIG_TOKEN,
   ENTITLEMENT_SERVICE_TOKEN,
@@ -250,7 +253,7 @@ function assertNoReplacesCycle(index) {
         ...path.slice(cycleStart),
         key
       ].join(" \u2192 ");
-      throw new Error(`replaces-Zyklus in den Discovery-Metadaten: ${cycle}. Feature-Ersetzungen m\xFCssen azyklisch sein \u2014 replaces-Deklarationen im Code korrigieren (#39).`);
+      throw new Error(`replaces cycle in the discovery metadata: ${cycle}. Feature replacements must be acyclic \u2014 fix the replaces declarations in code (#39).`);
     }
     state.set(key, IN_PROGRESS);
     for (const successor of index.get(key) ?? []) {
@@ -294,7 +297,7 @@ var LimitExceededError = class extends Error {
   used;
   code = LIMIT_EXCEEDED;
   constructor(dimension, max, used) {
-    super(`Limit f\xFCr ${dimension} erreicht: ${used}/${max}.`), this.dimension = dimension, this.max = max, this.used = used;
+    super(`Limit for ${dimension} reached: ${used}/${max}.`), this.dimension = dimension, this.max = max, this.used = used;
     this.name = "LimitExceededError";
   }
 };
@@ -304,7 +307,8 @@ function isLimitExceededError(err) {
 __name(isLimitExceededError, "isLimitExceededError");
 
 // src/entitlement/service.ts
-import { Inject, Injectable, NotFoundException, Optional } from "@nestjs/common";
+import { Inject, Injectable, InternalServerErrorException, NotFoundException, Optional } from "@nestjs/common";
+import { BILLING_ERROR_CODES } from "@saasicat/types";
 
 // src/billing/subscription-bundles.tokens.ts
 var SUBSCRIPTION_BUNDLE_REPOSITORY_TOKEN = /* @__PURE__ */ Symbol.for("saas-platform/SubscriptionBundleRepository");
@@ -371,7 +375,13 @@ var EntitlementService = class {
     if (cached) return cached;
     const sub = await this.subscriptions.findByTenantId(tenantId);
     if (!sub) {
-      throw new NotFoundException(`Keine Subscription f\xFCr Tenant ${tenantId}`);
+      throw new NotFoundException({
+        code: BILLING_ERROR_CODES.SUBSCRIPTION_NOT_FOUND,
+        message: `No subscription for tenant ${tenantId}`,
+        params: {
+          tenantId
+        }
+      });
     }
     const limits = await this.deriveLimits(sub, now);
     this.writeCache(tenantId, limits, now.getTime());
@@ -444,7 +454,7 @@ var EntitlementService = class {
     return Promise.all(active.map(async (booking) => {
       const bv = await this.bundles.findVersionById(booking.bundleVersionId, tx);
       if (!bv) {
-        throw new Error(`BundleVersion '${booking.bundleVersionId}' aus aktiver SubscriptionBundle nicht gefunden`);
+        throw new Error(`BundleVersion '${booking.bundleVersionId}' from an active subscription bundle not found`);
       }
       return {
         bundleKey: bv.bundleKey,
@@ -466,12 +476,21 @@ var EntitlementService = class {
     return this.tx.run(async (tx) => {
       const sub = await this.subscriptions.findByTenantIdLocked(input.tenantId, tx);
       if (!sub) {
-        throw new NotFoundException(`Keine Subscription f\xFCr Tenant ${input.tenantId}`);
+        throw new NotFoundException({
+          code: BILLING_ERROR_CODES.SUBSCRIPTION_NOT_FOUND,
+          message: `No subscription for tenant ${input.tenantId}`,
+          params: {
+            tenantId: input.tenantId
+          }
+        });
       }
       const limits = await this.deriveLimits(sub, now, tx);
       const max = limits.quotas[input.dimension];
       if (max === void 0) {
-        throw new Error(`Quota-Dimension "${input.dimension}" nicht im PlanCatalog (${this.catalog.projectKey}).`);
+        throw new InternalServerErrorException(codedError(BILLING_ERROR_CODES.QUOTA_DIMENSION_UNKNOWN, {
+          dimension: input.dimension,
+          projectKey: this.catalog.projectKey
+        }));
       }
       const used = await input.currentUsage(tx, input.tenantId);
       if (max !== -1 && used + delta > max) {
@@ -492,7 +511,15 @@ var EntitlementService = class {
   async findActivePlanVersionOrFallback(planId, asOf, tx) {
     const v = this.planVersions.findActive ? await this.planVersions.findActive(planId, asOf, tx) : await this.planVersions.findLatestLive(planId, tx);
     if (!v) {
-      throw new NotFoundException(`Keine zu ${asOf.toISOString().slice(0, 10)} aktive PlanVersion f\xFCr ${planId} \u2014 weder validFrom-window erf\xFCllt noch latest-live verf\xFCgbar.`);
+      const asOfDate = asOf.toISOString().slice(0, 10);
+      throw new NotFoundException({
+        code: BILLING_ERROR_CODES.NO_ACTIVE_PLAN_VERSION,
+        message: `No plan version for ${planId} active as of ${asOfDate} \u2014 neither the validFrom window is satisfied nor is a latest-live version available.`,
+        params: {
+          planId,
+          asOf: asOfDate
+        }
+      });
     }
     return v;
   }

package/dist/{chunk-32EMXPU2.js → chunk-B7NRY2LV.js}

@@ -1,6 +1,6 @@
 import {
   appendImplicitDiscountLineItem
-} from "./chunk-MDIZUVIK.js";
+} from "./chunk-BSK6YBLI.js";
 import {
   SUBSCRIPTION_CONTRACT_REPOSITORY_TOKEN
 } from "./chunk-NYLON2VC.js";
@@ -13,6 +13,7 @@ import {
 
 // src/subscription-contract/subscription-contract.service.ts
 import { ConflictException, Inject, Injectable, NotFoundException, UnprocessableEntityException } from "@nestjs/common";
+import { CONTRACT_ERROR_CODES } from "@saasicat/types";
 function _ts_decorate(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -44,7 +45,13 @@ var SubscriptionContractService = class {
   async getById(contractId) {
     const row = await this.repo.findById(contractId);
     if (!row) {
-      throw new NotFoundException(`SubscriptionContract '${contractId}' nicht gefunden`);
+      throw new NotFoundException({
+        code: CONTRACT_ERROR_CODES.SUBSCRIPTION_CONTRACT_NOT_FOUND,
+        message: `SubscriptionContract '${contractId}' not found`,
+        params: {
+          contractId
+        }
+      });
     }
     return row;
   }
@@ -54,7 +61,14 @@ var SubscriptionContractService = class {
   async getActiveInvoiceSnapshotForTenant(tenantId, asOf = /* @__PURE__ */ new Date()) {
     const contract = await this.repo.findActiveByTenantId(tenantId, asOf);
     if (!contract) {
-      throw new NotFoundException(`Kein aktiver SubscriptionContract f\xFCr Tenant ${tenantId}`);
+      throw new NotFoundException({
+        code: CONTRACT_ERROR_CODES.NO_ACTIVE_SUBSCRIPTION_CONTRACT,
+        message: `No active subscription contract for tenant ${tenantId}`,
+        params: {
+          tenantId,
+          asOf: asOf.toISOString()
+        }
+      });
     }
     return subscriptionContractToInvoiceSnapshot(contract);
   }
@@ -87,7 +101,14 @@ var SubscriptionContractService = class {
   }
   createDataFromOffer(offer, options) {
     if (offer.status !== "consumed") {
-      throw new ConflictException(`CheckoutOffer '${offer.id}' muss vor Contract-Erstellung consumed sein`);
+      throw new ConflictException({
+        code: CONTRACT_ERROR_CODES.CHECKOUT_OFFER_NOT_CONSUMED,
+        message: `CheckoutOffer '${offer.id}' must be consumed before the contract is created`,
+        params: {
+          offerId: offer.id,
+          status: offer.status
+        }
+      });
     }
     const lineItems = this.lineItemsFromOffer(offer);
     return {
@@ -120,8 +141,8 @@ var SubscriptionContractService = class {
     const source = offer.lineItems ?? [];
     if (source.length === 0) {
       throw new UnprocessableEntityException({
-        code: "CHECKOUT_OFFER_LINE_ITEMS_REQUIRED",
-        message: "Aus einem CheckoutOffer kann nur ein Contract entstehen, wenn LineItems eingefroren sind."
+        code: CONTRACT_ERROR_CODES.CHECKOUT_OFFER_LINE_ITEMS_REQUIRED,
+        message: "A checkout offer can yield only one contract, and only once its line items are frozen."
       });
     }
     return appendImplicitDiscountLineItem({
@@ -159,8 +180,11 @@ var SubscriptionContractService = class {
     const date = value instanceof Date ? new Date(value) : new Date(value);
     if (Number.isNaN(date.getTime())) {
       throw new UnprocessableEntityException({
-        code: "SUBSCRIPTION_CONTRACT_INVALID_DATE",
-        message: `${field} muss ein g\xFCltiges Datum sein.`
+        code: CONTRACT_ERROR_CODES.SUBSCRIPTION_CONTRACT_INVALID_DATE,
+        message: `${field} must be a valid date.`,
+        params: {
+          field
+        }
       });
     }
     return date;
@@ -180,32 +204,39 @@ var SubscriptionContractService = class {
   assertCreateData(data) {
     if (data.lineItems.length === 0) {
       throw new UnprocessableEntityException({
-        code: "SUBSCRIPTION_CONTRACT_LINE_ITEMS_REQUIRED",
-        message: "SubscriptionContract ben\xF6tigt mindestens eine LineItem."
+        code: CONTRACT_ERROR_CODES.SUBSCRIPTION_CONTRACT_LINE_ITEMS_REQUIRED,
+        message: "A subscription contract requires at least one line item."
       });
     }
     if (data.effectiveUntil && data.effectiveUntil <= data.effectiveFrom) {
       throw new UnprocessableEntityException({
-        code: "SUBSCRIPTION_CONTRACT_INVALID_WINDOW",
-        message: "effectiveUntil muss nach effectiveFrom liegen."
+        code: CONTRACT_ERROR_CODES.SUBSCRIPTION_CONTRACT_INVALID_WINDOW,
+        message: "effectiveUntil must be after effectiveFrom."
       });
     }
     const planLineItems = data.lineItems.filter((item) => item.kind === "plan");
     if (planLineItems.length !== 1) {
       throw new UnprocessableEntityException({
-        code: "SUBSCRIPTION_CONTRACT_PLAN_LINE_ITEM_REQUIRED",
-        message: "SubscriptionContract ben\xF6tigt genau eine Plan-Grundposition."
+        code: CONTRACT_ERROR_CODES.SUBSCRIPTION_CONTRACT_PLAN_LINE_ITEM_REQUIRED,
+        message: "A subscription contract requires exactly one plan base item."
       });
     }
   }
   assertTerminable(existing, data) {
     if (existing.status === "terminated" || existing.status === "superseded") {
-      throw new ConflictException(`SubscriptionContract '${existing.id}' ist bereits geschlossen`);
+      throw new ConflictException({
+        code: CONTRACT_ERROR_CODES.SUBSCRIPTION_CONTRACT_ALREADY_CLOSED,
+        message: `SubscriptionContract '${existing.id}' is already closed`,
+        params: {
+          contractId: existing.id,
+          status: existing.status
+        }
+      });
     }
     if (data.effectiveUntil <= existing.effectiveFrom) {
       throw new UnprocessableEntityException({
-        code: "SUBSCRIPTION_CONTRACT_TERMINATION_BEFORE_START",
-        message: "effectiveUntil muss nach effectiveFrom des Contracts liegen."
+        code: CONTRACT_ERROR_CODES.SUBSCRIPTION_CONTRACT_TERMINATION_BEFORE_START,
+        message: "effectiveUntil must be after the effectiveFrom of the contract."
       });
     }
   }

package/dist/{chunk-MDIZUVIK.js → chunk-BSK6YBLI.js}

@@ -40,7 +40,7 @@ function createDiscountLineItem(input, discountNet) {
     kind: "discount",
     sourceKey: promoCode?.code ?? firstPromotion?.id ?? "price-discount",
     sourceVersionId: null,
-    titleSnapshot: promoCode?.label ?? firstPromotion?.label ?? "Rabatt",
+    titleSnapshot: promoCode?.label ?? firstPromotion?.label ?? "Discount",
     descriptionSnapshot: promoCode ? `Promo-Code ${promoCode.code}` : null,
     quantity: 1,
     unit: null,

package/dist/{chunk-R2QOSVAA.js → chunk-DQKCK7DX.js}

@@ -152,7 +152,7 @@ __name(findPlan, "findPlan");
 function getPlanOrThrow(catalog, planId) {
   const plan = findPlan(catalog, planId);
   if (!plan) {
-    throw new Error(`Plan "${planId}" nicht im Catalog (${catalog.projectKey}) gefunden`);
+    throw new Error(`Plan "${planId}" not found in the catalog (${catalog.projectKey})`);
   }
   return plan;
 }

package/dist/chunk-EBJJNTW6.js

@@ -0,0 +1,22 @@
+import {
+  __name
+} from "./chunk-SHUYVCID.js";
+
+// src/errors/coded-error.ts
+import { ERROR_MESSAGES_EN, formatErrorMessage } from "@saasicat/types";
+function codedError(code, params) {
+  const message = formatErrorMessage(ERROR_MESSAGES_EN[code], params ?? {});
+  return params ? {
+    code,
+    message,
+    params
+  } : {
+    code,
+    message
+  };
+}
+__name(codedError, "codedError");
+
+export {
+  codedError
+};