@saasicat/nest 0.2.0

package/dist/chunk-RIGLQ4BV.js

@@ -0,0 +1,3367 @@
+import {
+  PromoCodesService
+} from "./chunk-ZL4LLE2Z.js";
+import {
+  SubscriptionContractService
+} from "./chunk-2PNX2QL2.js";
+import {
+  AUDIT_CONTEXT_RESOLVER_TOKEN,
+  PENDING_PLAN_QUERY_PORT_TOKEN,
+  SUBSCRIPTION_USAGE_PORT_TOKEN,
+  SUBSCRIPTION_WRITE_PORT_TOKEN,
+  TENANT_AUTH_GUARDS_TOKEN,
+  TENANT_ID_RESOLVER_TOKEN,
+  TRIAL_PROJECTION_PORT_TOKEN,
+  USAGE_SNAPSHOT_PORT_TOKEN,
+  USER_EMAIL_RESOLVER_TOKEN,
+  USER_ID_RESOLVER_TOKEN
+} from "./chunk-WPUVJRIN.js";
+import {
+  REQUIRE_FEATURE_KEY
+} from "./chunk-Q53N43LQ.js";
+import {
+  AdminAuditService
+} from "./chunk-E56W4U2P.js";
+import {
+  EntitlementService,
+  LimitExceededError,
+  SUBSCRIPTION_BUNDLE_CONFIG_TOKEN,
+  SUBSCRIPTION_BUNDLE_REPOSITORY_TOKEN,
+  toEffectiveLimitsSnapshot
+} from "./chunk-YXGHPILG.js";
+import {
+  PLAN_CATALOG_TOKEN,
+  findPlan,
+  getMarketedPlans,
+  getPlanPriceNet
+} from "./chunk-MV6LW5UB.js";
+import {
+  SUBSCRIPTION_CONTRACT_REPOSITORY_TOKEN
+} from "./chunk-NYLON2VC.js";
+import {
+  BUNDLE_REPOSITORY_TOKEN,
+  CATALOG_ENTRY_REPOSITORY_TOKEN,
+  PLAN_REPOSITORY_TOKEN
+} from "./chunk-XCZ3TTFK.js";
+import {
+  asProvider
+} from "./chunk-SABTXESR.js";
+import {
+  __name
+} from "./chunk-SHUYVCID.js";
+
+// src/billing/billing-period.ts
+function advanceOneCycle(d, cycle) {
+  const out = new Date(d);
+  if (cycle === "YEARLY") {
+    out.setUTCFullYear(out.getUTCFullYear() + 1);
+  } else {
+    out.setUTCMonth(out.getUTCMonth() + 1);
+  }
+  return out;
+}
+__name(advanceOneCycle, "advanceOneCycle");
+function periodEndAfter(startedAt, cycle, after) {
+  let candidate = new Date(startedAt ?? after);
+  while (candidate <= after) {
+    candidate = advanceOneCycle(candidate, cycle);
+  }
+  return candidate;
+}
+__name(periodEndAfter, "periodEndAfter");
+function initialPeriodWindow(startedAt, cycle) {
+  return {
+    start: startedAt,
+    end: advanceOneCycle(startedAt, cycle)
+  };
+}
+__name(initialPeriodWindow, "initialPeriodWindow");
+function periodEndWithMinLead(startedAt, cycle, now, minLeadDays = 42) {
+  const minLeadMs = minLeadDays * 864e5;
+  let candidate = periodEndAfter(startedAt, cycle, now);
+  while (candidate.getTime() - now.getTime() < minLeadMs) {
+    candidate = advanceOneCycle(candidate, cycle);
+  }
+  return candidate;
+}
+__name(periodEndWithMinLead, "periodEndWithMinLead");
+
+// src/billing/version-publish.ts
+var PublishValidationError = class extends Error {
+  static {
+    __name(this, "PublishValidationError");
+  }
+  code;
+  constructor(code, message) {
+    super(message), this.code = code;
+    this.name = "PublishValidationError";
+  }
+};
+function assertChangeNote(changeNote) {
+  const trimmed = (changeNote ?? "").trim();
+  if (trimmed.length === 0) {
+    throw new PublishValidationError("CHANGE_NOTE_REQUIRED", "changeNote ist Pflicht beim Ver\xF6ffentlichen einer Version.");
+  }
+  return trimmed;
+}
+__name(assertChangeNote, "assertChangeNote");
+function assertDraftPublishable(draft, draftId) {
+  if (!draft) {
+    throw new PublishValidationError("NOT_FOUND", `PlanVersion ${draftId} nicht gefunden`);
+  }
+  if (draft.publishedAt !== null) {
+    throw new PublishValidationError("ALREADY_PUBLISHED", `PlanVersion ${draftId} ist bereits ver\xF6ffentlicht.`);
+  }
+  if (!draft.baseVersionId) {
+    throw new PublishValidationError("NO_BASE_VERSION", `Draft ${draftId} hat keine baseVersion \u2014 wahrscheinlich manuell angelegtes v1, das nur per Migration ver\xF6ffentlicht werden darf.`);
+  }
+}
+__name(assertDraftPublishable, "assertDraftPublishable");
+function assertBaseVersionFresh(base, baseId, planContext) {
+  if (!base) {
+    throw new PublishValidationError("BASE_NOT_FOUND", `baseVersion ${baseId} nicht mehr vorhanden.`);
+  }
+  if (base.supersededAt !== null) {
+    throw new PublishValidationError("BASE_SUPERSEDED", `Draft basiert auf einer abgel\xF6sten Version (${planContext}). Bitte den Draft gegen die aktuelle Live-Version rebasen oder neu anlegen.`);
+  }
+}
+__name(assertBaseVersionFresh, "assertBaseVersionFresh");
+function assertOptimisticLockHeld(updateCount, draftId) {
+  if (updateCount !== 1) {
+    throw new PublishValidationError("OPTIMISTIC_LOCK_CONFLICT", `Draft ${draftId} wurde zwischenzeitlich von einem anderen Admin ver\xF6ffentlicht.`);
+  }
+}
+__name(assertOptimisticLockHeld, "assertOptimisticLockHeld");
+
+// src/billing/version-renewal.ts
+function decideRenewal(sub, now) {
+  if (!sub.pendingPlanVersionId || !sub.pendingPlanVersionEffectiveAt) return "SKIP";
+  if (sub.pendingPlanVersionEffectiveAt > now) return "SKIP";
+  if (sub.pendingPlanVersionNonRegressive || sub.pendingPlanVersionAccepted) {
+    return "ROLL_FORWARD";
+  }
+  return "CLEAR_PENDING";
+}
+__name(decideRenewal, "decideRenewal");
+function clearPendingPlanVersionFields() {
+  return {
+    pendingPlanVersionId: null,
+    pendingPlanVersionEffectiveAt: null,
+    pendingPlanVersionAccepted: false,
+    pendingPlanVersionAcceptedAt: null,
+    pendingPlanVersionAcceptedByUserId: null,
+    pendingPlanVersionNotifiedAt: null,
+    pendingPlanVersionReminderSentAt: null
+  };
+}
+__name(clearPendingPlanVersionFields, "clearPendingPlanVersionFields");
+function computeNextPeriod(sub, now) {
+  if (sub.canceledAt !== null) return null;
+  if (sub.currentPeriodEnd === null) return null;
+  if (sub.currentPeriodEnd > now) return null;
+  const newStart = sub.currentPeriodEnd;
+  const newEnd = periodEndAfter(newStart, sub.billingCycle, now);
+  return {
+    currentPeriodStart: newStart,
+    currentPeriodEnd: newEnd
+  };
+}
+__name(computeNextPeriod, "computeNextPeriod");
+
+// src/billing/feature-guard.tokens.ts
+var FEATURE_GUARD_CONFIG_TOKEN = /* @__PURE__ */ Symbol("FEATURE_GUARD_CONFIG");
+
+// src/billing/feature.guard.ts
+import { ForbiddenException, Inject, Injectable, Logger, Optional } from "@nestjs/common";
+import { Reflector } from "@nestjs/core";
+import { FEATURE_NOT_LICENSED } from "@saasicat/types";
+
+// src/billing/upsell.tokens.ts
+var UPSELL_OFFER_RESOLVER_TOKEN = /* @__PURE__ */ Symbol.for("saas-platform/UpsellOfferResolver");
+var UPSELL_OFFER_CURRENCY_TOKEN = /* @__PURE__ */ Symbol.for("saas-platform/UpsellOfferCurrency");
+
+// src/billing/feature.guard.ts
+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);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+function _ts_param(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param, "_ts_param");
+var FeatureGuard = class _FeatureGuard {
+  static {
+    __name(this, "FeatureGuard");
+  }
+  reflector;
+  entitlements;
+  config;
+  upsellResolver;
+  logger = new Logger(_FeatureGuard.name);
+  constructor(reflector, entitlements, config = null, upsellResolver = null) {
+    this.reflector = reflector;
+    this.entitlements = entitlements;
+    this.config = config;
+    this.upsellResolver = upsellResolver;
+  }
+  async canActivate(context) {
+    const required = this.reflector.getAllAndOverride(REQUIRE_FEATURE_KEY, [
+      context.getHandler(),
+      context.getClass()
+    ]);
+    if (!required || required.length === 0) return true;
+    const request = context.switchToHttp().getRequest();
+    const user = request.user;
+    if (!user) throw new ForbiddenException("Nicht authentifiziert");
+    const role = this.config?.userRoleResolver ? this.config.userRoleResolver(user) : user.role ?? user.platformRole;
+    if (role === "SUPER_ADMIN") return true;
+    const tenantId = this.config?.tenantIdResolver ? this.config.tenantIdResolver(request) : request.tenantId ?? user.tenantId;
+    if (!tenantId) throw new ForbiddenException("Kein Mandant zugeordnet");
+    const compute = /* @__PURE__ */ __name(() => this.entitlements.computeLimits(tenantId), "compute");
+    const limits = this.config?.tenantContextRunner ? await this.config.tenantContextRunner(tenantId, compute) : await compute();
+    const allowed = required.some((f) => limits.features.has(f));
+    if (!allowed) {
+      throw await this.buildNotLicensedException(required, tenantId);
+    }
+    return true;
+  }
+  /**
+   * Upsell response (#36): with a registered `UpsellOfferResolver` the 403
+   * becomes machine-readable (`FeatureNotLicensedBody`), so consumer UIs can
+   * render a purchase offer. Without a resolver the previous plain 403
+   * remains — no breaking change.
+   *
+   * Deliberately 403 + `code` field instead of 402 — rationale in
+   * `@saasicat/types` upsell.types.ts (402 is reserved / inconsistently
+   * supported; SPA interceptors must not treat the 403 as an auth error, the
+   * distinction runs through `code`).
+   */
+  async buildNotLicensedException(required, tenantId) {
+    const message = `Feature ${required.join(" / ")} nicht im aktuellen Paket enthalten.`;
+    if (!this.upsellResolver) return new ForbiddenException(message);
+    const body = {
+      code: FEATURE_NOT_LICENSED,
+      featureKey: required[0],
+      featureKeys: required,
+      offers: await this.resolveOffersSafe(required, tenantId),
+      message
+    };
+    return new ForbiddenException(body);
+  }
+  /**
+   * A resolver error must not turn the semantically correct 403 into a 500 —
+   * degrade to empty offers and log.
+   */
+  async resolveOffersSafe(required, tenantId) {
+    try {
+      return await this.upsellResolver.resolveOffers(required, tenantId);
+    } catch (error) {
+      this.logger.warn(`UpsellOfferResolver fehlgeschlagen f\xFCr [${required.join(", ")}]: ${String(error)}`);
+      return [];
+    }
+  }
+};
+FeatureGuard = _ts_decorate([
+  Injectable(),
+  _ts_param(0, Inject(Reflector)),
+  _ts_param(1, Inject(EntitlementService)),
+  _ts_param(2, Optional()),
+  _ts_param(2, Inject(FEATURE_GUARD_CONFIG_TOKEN)),
+  _ts_param(3, Optional()),
+  _ts_param(3, Inject(UPSELL_OFFER_RESOLVER_TOKEN)),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof Reflector === "undefined" ? Object : Reflector,
+    typeof EntitlementService === "undefined" ? Object : EntitlementService,
+    Object,
+    Object
+  ])
+], FeatureGuard);
+
+// src/billing/catalog-bundle-upsell-resolver.ts
+import { Inject as Inject2, Injectable as Injectable2, Optional as Optional2 } from "@nestjs/common";
+import { buildFeatureRequiresIndex, collectUnsatisfiedRequires } from "@saasicat/types";
+
+// src/billing/public-catalog.tokens.ts
+var PUBLIC_CATALOG_PROJECT_KEY_TOKEN = /* @__PURE__ */ Symbol("PUBLIC_CATALOG_PROJECT_KEY");
+var PUBLIC_CATALOG_BUNDLE_REPOSITORY_TOKEN = /* @__PURE__ */ Symbol("PUBLIC_CATALOG_BUNDLE_REPOSITORY");
+var PUBLIC_CATALOG_BUSINESS_TYPE_REPOSITORY_TOKEN = /* @__PURE__ */ Symbol("PUBLIC_CATALOG_BUSINESS_TYPE_REPOSITORY");
+var PUBLIC_CATALOG_MARKETING_REPOSITORY_TOKEN = /* @__PURE__ */ Symbol("PUBLIC_CATALOG_MARKETING_REPOSITORY");
+var PUBLIC_CATALOG_CATALOG_ENTRY_REPOSITORY_TOKEN = /* @__PURE__ */ Symbol("PUBLIC_CATALOG_CATALOG_ENTRY_REPOSITORY");
+
+// src/billing/catalog-bundle-upsell-resolver.ts
+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);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate2, "_ts_decorate");
+function _ts_metadata2(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata2, "_ts_metadata");
+function _ts_param2(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param2, "_ts_param");
+var DEFAULT_CURRENCY = "EUR";
+var CatalogBundleUpsellResolver = class {
+  static {
+    __name(this, "CatalogBundleUpsellResolver");
+  }
+  bundleRepo;
+  projectKey;
+  catalogEntryRepo;
+  currency;
+  constructor(bundleRepo, projectKey, catalogEntryRepo = null, currency = null) {
+    this.bundleRepo = bundleRepo;
+    this.projectKey = projectKey;
+    this.catalogEntryRepo = catalogEntryRepo;
+    this.currency = currency;
+  }
+  async resolveOffers(featureKeys, tenantId) {
+    void tenantId;
+    if (featureKeys.length === 0) return [];
+    const missing = new Set(featureKeys);
+    const wanted = /* @__PURE__ */ new Set([
+      ...featureKeys,
+      ...await this.lookupUnmetRequires(featureKeys)
+    ]);
+    const ranked = [];
+    for (const live of await this.listLiveMarketedBundles()) {
+      const features = live.features;
+      if (!features.some((key) => missing.has(key))) continue;
+      ranked.push({
+        offer: this.toOffer(live),
+        coverage: features.filter((key) => wanted.has(key)).length
+      });
+    }
+    return ranked.sort(compareRankedOffers).map((r) => r.offer);
+  }
+  /**
+   * Uncovered dependencies of the missing features (#35) — feed into the
+   * coverage ranking. Without a CatalogEntryRepository: empty (ranking
+   * degrades to price).
+   */
+  async lookupUnmetRequires(featureKeys) {
+    if (!this.catalogEntryRepo) return [];
+    const rows = await this.catalogEntryRepo.listFeatures({
+      projectKey: this.projectKey
+    });
+    return collectUnsatisfiedRequires(featureKeys, buildFeatureRequiresIndex(rows));
+  }
+  /** Only published-and-live AND marketed — non-marketed bundles are not an offer. */
+  async listLiveMarketedBundles() {
+    const stems = await this.bundleRepo.list({
+      projectKey: this.projectKey,
+      excludeDeleted: true
+    });
+    const out = [];
+    for (const stem of stems) {
+      const live = await this.bundleRepo.findLatestLive(stem.id);
+      if (live?.marketed) out.push(live);
+    }
+    return out;
+  }
+  toOffer(live) {
+    return {
+      bundleKey: live.bundleKey,
+      bundleVersionId: live.id,
+      priceMonthlyNet: parsePrice(live.monthlyNet),
+      currency: this.currency ?? DEFAULT_CURRENCY,
+      label: live.label
+    };
+  }
+};
+CatalogBundleUpsellResolver = _ts_decorate2([
+  Injectable2(),
+  _ts_param2(0, Inject2(PUBLIC_CATALOG_BUNDLE_REPOSITORY_TOKEN)),
+  _ts_param2(1, Inject2(PUBLIC_CATALOG_PROJECT_KEY_TOKEN)),
+  _ts_param2(2, Optional2()),
+  _ts_param2(2, Inject2(PUBLIC_CATALOG_CATALOG_ENTRY_REPOSITORY_TOKEN)),
+  _ts_param2(3, Optional2()),
+  _ts_param2(3, Inject2(UPSELL_OFFER_CURRENCY_TOKEN)),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof BundleRepository === "undefined" ? Object : BundleRepository,
+    String,
+    Object,
+    Object
+  ])
+], CatalogBundleUpsellResolver);
+function parsePrice(decimal) {
+  if (decimal === null) return null;
+  const n = Number.parseFloat(decimal);
+  return Number.isFinite(n) ? n : null;
+}
+__name(parsePrice, "parsePrice");
+function compareRankedOffers(a, b) {
+  if (a.coverage !== b.coverage) return b.coverage - a.coverage;
+  const priceA = a.offer.priceMonthlyNet ?? Number.POSITIVE_INFINITY;
+  const priceB = b.offer.priceMonthlyNet ?? Number.POSITIVE_INFINITY;
+  if (priceA !== priceB) return priceA - priceB;
+  return a.offer.bundleKey.localeCompare(b.offer.bundleKey);
+}
+__name(compareRankedOffers, "compareRankedOffers");
+
+// src/billing/limit-exceeded.filter.ts
+import { Catch, HttpStatus, Logger as Logger2 } from "@nestjs/common";
+function _ts_decorate3(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate3, "_ts_decorate");
+var LimitExceededFilter = class _LimitExceededFilter {
+  static {
+    __name(this, "LimitExceededFilter");
+  }
+  logger = new Logger2(_LimitExceededFilter.name);
+  catch(exception, host) {
+    const ctx = host.switchToHttp();
+    const response = ctx.getResponse();
+    const request = ctx.getRequest();
+    this.logger.warn(`Limit ${exception.dimension} \xFCberschritten: ${exception.used}/${exception.max} bei ${request.method ?? "?"} ${request.url ?? ""}`);
+    response.status(HttpStatus.PAYMENT_REQUIRED).send({
+      statusCode: HttpStatus.PAYMENT_REQUIRED,
+      error: "PaymentRequired",
+      reason: "LIMIT_EXCEEDED",
+      dimension: exception.dimension,
+      used: exception.used,
+      max: exception.max,
+      message: exception.message
+    });
+  }
+};
+LimitExceededFilter = _ts_decorate3([
+  Catch(LimitExceededError)
+], LimitExceededFilter);
+
+// src/billing/plan-catalog-loader.ts
+import { readFileSync } from "fs";
+import { resolve as resolvePath } from "path";
+import yaml from "js-yaml";
+import Ajv2020 from "ajv/dist/2020.js";
+import addFormats from "ajv-formats";
+import { planCatalogSchema } from "@saasicat/spec";
+var PlanCatalogValidationError = class extends Error {
+  static {
+    __name(this, "PlanCatalogValidationError");
+  }
+  source;
+  errors;
+  constructor(source, errors) {
+    const messages = errors.map((e) => `${e.instancePath || "/"}: ${e.message ?? "unbekannt"}`).join("\n  ");
+    super(`Plan-Catalog-Validierung fehlgeschlagen f\xFCr ${source}:
+  ${messages}`), this.source = source, this.errors = errors;
+    this.name = "PlanCatalogValidationError";
+  }
+};
+function loadPlanCatalogFromFile(opts) {
+  const absolutePath = resolvePath(opts.path);
+  const raw = readFileSync(absolutePath, "utf-8");
+  return loadPlanCatalogFromString(raw, {
+    source: absolutePath,
+    crossFieldChecks: opts.crossFieldChecks ?? true
+  });
+}
+__name(loadPlanCatalogFromFile, "loadPlanCatalogFromFile");
+function loadPlanCatalogFromString(yamlContent, opts) {
+  const parsed = yaml.load(yamlContent);
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`YAML-Inhalt von ${opts.source} ist kein Objekt`);
+  }
+  const ajv = new Ajv2020({
+    strict: false,
+    allErrors: true
+  });
+  addFormats.default(ajv);
+  const validate = ajv.compile(planCatalogSchema);
+  if (!validate(parsed)) {
+    throw new PlanCatalogValidationError(opts.source, validate.errors ?? []);
+  }
+  const catalog = parsed;
+  if (opts.crossFieldChecks ?? true) {
+    validateConsistency(catalog, opts.source);
+  }
+  return catalog;
+}
+__name(loadPlanCatalogFromString, "loadPlanCatalogFromString");
+function validateConsistency(catalog, source) {
+  const errors = [];
+  const declaredFeatureKeys = new Set((catalog.features ?? []).map((f) => f.key));
+  const planIds = /* @__PURE__ */ new Set();
+  for (const plan of catalog.plans ?? []) {
+    if (planIds.has(plan.id)) {
+      errors.push(`plans[].id: Doppelte Plan-ID "${plan.id}"`);
+    }
+    planIds.add(plan.id);
+    if (catalog.features) {
+      for (const fk of plan.features) {
+        if (!declaredFeatureKeys.has(fk)) {
+          errors.push(`plans[id=${plan.id}].features: Unbekannter featureKey "${fk}" \u2014 nicht in catalog.features deklariert`);
+        }
+      }
+    }
+  }
+  if (errors.length > 0) {
+    const err = new Error(`Plan-Catalog-Konsistenz-Fehler in ${source}:
+  ${errors.join("\n  ")}`);
+    err.name = "PlanCatalogConsistencyError";
+    throw err;
+  }
+}
+__name(validateConsistency, "validateConsistency");
+
+// src/billing/plan-catalog-importer.service.ts
+import { Inject as Inject3, Injectable as Injectable3 } from "@nestjs/common";
+function _ts_decorate4(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate4, "_ts_decorate");
+function _ts_metadata3(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata3, "_ts_metadata");
+function _ts_param3(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param3, "_ts_param");
+var PLAN_CATALOG_IMPORT_SINK_TOKEN = /* @__PURE__ */ Symbol("PLAN_CATALOG_IMPORT_SINK");
+var IMPORT_CHANGE_NOTE = "Initial import from saas.yaml (SPEC_V2 \xA711.1 M6 Pack 2c)";
+var PlanCatalogImporterService = class {
+  static {
+    __name(this, "PlanCatalogImporterService");
+  }
+  sink;
+  constructor(sink) {
+    this.sink = sink;
+  }
+  /**
+   * Import directly from a YAML string. Apps pass the contents of the
+   * `saas.yaml` through via the HTTP body; CLI tools can read the file
+   * contents themselves beforehand.
+   *
+   * @throws on a schema failure of the YAML (validated first via the loader).
+   */
+  async importFromYaml(yamlContent, opts = {}) {
+    const catalog = loadPlanCatalogFromString(yamlContent, {
+      source: opts.source ?? "http-import",
+      crossFieldChecks: opts.crossFieldChecks ?? true
+    });
+    return this.importCatalog(catalog);
+  }
+  async importCatalog(catalog) {
+    const report = {
+      plansCreated: 0,
+      plansSkipped: 0,
+      planVersionsCreated: 0,
+      planVersionsSkipped: 0,
+      featureEntriesCreated: 0,
+      featureEntriesSkipped: 0,
+      warnings: []
+    };
+    for (const feature of catalog.features ?? []) {
+      const result = await this.sink.upsertFeatureCatalogEntry({
+        projectKey: catalog.projectKey,
+        featureKey: feature.key,
+        label: feature.label,
+        icon: feature.icon,
+        tier: feature.tier,
+        plannedOnly: feature.plannedOnly
+      });
+      if (result.created) report.featureEntriesCreated++;
+      else report.featureEntriesSkipped++;
+    }
+    for (const plan of catalog.plans ?? []) {
+      const planResult = await this.sink.upsertPlan({
+        projectKey: catalog.projectKey,
+        planKey: plan.id,
+        label: plan.name ?? plan.id,
+        description: plan.tagline ?? null
+      });
+      if (planResult.created) report.plansCreated++;
+      else report.plansSkipped++;
+      if (plan.monthlyNet === null || plan.monthlyNet === void 0) {
+        report.warnings.push(`Plan '${plan.id}' hat keinen monthlyNet \u2014 \xFCbersprungen (auf-Anfrage-Plans brauchen manuelle PlanVersion).`);
+        continue;
+      }
+      const versionResult = await this.sink.upsertPlanVersion({
+        planKey: plan.id,
+        version: 1,
+        features: plan.features,
+        quotas: plan.quotas,
+        monthlyNet: plan.monthlyNet.toFixed(2),
+        yearlyNet: (plan.yearlyNet ?? plan.monthlyNet * 10).toFixed(2),
+        marketed: plan.marketed ?? true,
+        publish: true,
+        changeNote: IMPORT_CHANGE_NOTE
+      });
+      if (versionResult.created) report.planVersionsCreated++;
+      else report.planVersionsSkipped++;
+    }
+    return report;
+  }
+};
+PlanCatalogImporterService = _ts_decorate4([
+  Injectable3(),
+  _ts_param3(0, Inject3(PLAN_CATALOG_IMPORT_SINK_TOKEN)),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof PlanCatalogImportSink === "undefined" ? Object : PlanCatalogImportSink
+  ])
+], PlanCatalogImporterService);
+
+// src/billing/plan-catalog-importer.module.ts
+import { Module } from "@nestjs/common";
+
+// src/billing/plan-catalog-importer.controller.ts
+import { Body, Controller, Inject as Inject4, Post, UseGuards } from "@nestjs/common";
+import { IsBoolean, IsOptional, IsString, MinLength } from "class-validator";
+function _ts_decorate5(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate5, "_ts_decorate");
+function _ts_metadata4(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata4, "_ts_metadata");
+function _ts_param4(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param4, "_ts_param");
+var PlanCatalogImportDto = class {
+  static {
+    __name(this, "PlanCatalogImportDto");
+  }
+  yamlContent;
+  crossFieldChecks;
+};
+_ts_decorate5([
+  IsString(),
+  MinLength(1),
+  _ts_metadata4("design:type", String)
+], PlanCatalogImportDto.prototype, "yamlContent", void 0);
+_ts_decorate5([
+  IsOptional(),
+  IsBoolean(),
+  _ts_metadata4("design:type", Boolean)
+], PlanCatalogImportDto.prototype, "crossFieldChecks", void 0);
+function buildPlanCatalogImporterController(guards) {
+  let GeneratedPlanCatalogImporterController = class GeneratedPlanCatalogImporterController {
+    static {
+      __name(this, "GeneratedPlanCatalogImporterController");
+    }
+    service;
+    constructor(service) {
+      this.service = service;
+    }
+    async import(dto) {
+      return this.service.importFromYaml(dto.yamlContent, {
+        crossFieldChecks: dto.crossFieldChecks
+      });
+    }
+  };
+  _ts_decorate5([
+    Post("import"),
+    _ts_param4(0, Body()),
+    _ts_metadata4("design:type", Function),
+    _ts_metadata4("design:paramtypes", [
+      typeof PlanCatalogImportDto === "undefined" ? Object : PlanCatalogImportDto
+    ]),
+    _ts_metadata4("design:returntype", Promise)
+  ], GeneratedPlanCatalogImporterController.prototype, "import", null);
+  GeneratedPlanCatalogImporterController = _ts_decorate5([
+    Controller("admin/billing/plan-catalog"),
+    UseGuards(...guards),
+    _ts_param4(0, Inject4(PlanCatalogImporterService)),
+    _ts_metadata4("design:type", Function),
+    _ts_metadata4("design:paramtypes", [
+      typeof PlanCatalogImporterService === "undefined" ? Object : PlanCatalogImporterService
+    ])
+  ], GeneratedPlanCatalogImporterController);
+  return GeneratedPlanCatalogImporterController;
+}
+__name(buildPlanCatalogImporterController, "buildPlanCatalogImporterController");
+
+// src/billing/plan-catalog-importer.module.ts
+function _ts_decorate6(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate6, "_ts_decorate");
+var PlanCatalogImporterModule = class _PlanCatalogImporterModule {
+  static {
+    __name(this, "PlanCatalogImporterModule");
+  }
+  static forRoot(options) {
+    const providers = [
+      ...options.extraProviders ?? [],
+      asProvider(PLAN_CATALOG_IMPORT_SINK_TOKEN, options.sink),
+      PlanCatalogImporterService
+    ];
+    const controllers = [];
+    if (options.controller) {
+      controllers.push(buildPlanCatalogImporterController(options.controller.guards));
+    }
+    return {
+      module: _PlanCatalogImporterModule,
+      global: options.global ?? false,
+      imports: options.imports ?? [],
+      controllers,
+      providers,
+      exports: [
+        PlanCatalogImporterService
+      ]
+    };
+  }
+};
+PlanCatalogImporterModule = _ts_decorate6([
+  Module({})
+], PlanCatalogImporterModule);
+
+// src/billing/feature-ui-registry.tokens.ts
+var FEATURE_UI_REGISTRY_TOKEN = /* @__PURE__ */ Symbol.for("saas-platform/FeatureUiRegistry");
+
+// src/billing/public-catalog.controller.ts
+import { Controller as Controller2, Get, Inject as Inject5, Optional as Optional3, Query } from "@nestjs/common";
+import { buildFeatureRequiresIndex as buildFeatureRequiresIndex2, collectUnsatisfiedRequires as collectUnsatisfiedRequires2 } from "@saasicat/types";
+function _ts_decorate7(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate7, "_ts_decorate");
+function _ts_metadata5(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata5, "_ts_metadata");
+function _ts_param5(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param5, "_ts_param");
+var PublicCatalogController = class {
+  static {
+    __name(this, "PublicCatalogController");
+  }
+  planCatalog;
+  featureRegistry;
+  projectKey;
+  marketingRepo;
+  bundleRepo;
+  businessTypeRepo;
+  catalogEntryRepo;
+  constructor(planCatalog, featureRegistry, projectKey = null, marketingRepo = null, bundleRepo = null, businessTypeRepo = null, catalogEntryRepo = null) {
+    this.planCatalog = planCatalog;
+    this.featureRegistry = featureRegistry;
+    this.projectKey = projectKey;
+    this.marketingRepo = marketingRepo;
+    this.bundleRepo = bundleRepo;
+    this.businessTypeRepo = businessTypeRepo;
+    this.catalogEntryRepo = catalogEntryRepo;
+  }
+  async listPlans(lang, localeParam = "de") {
+    const locale = lang || localeParam;
+    const plans = getMarketedPlans(this.planCatalog).map((plan) => ({
+      id: plan.id,
+      name: plan.name ?? plan.id,
+      tagline: plan.tagline ?? "",
+      monthlyNet: plan.monthlyNet ?? null,
+      yearlyNet: plan.yearlyNet ?? null,
+      popular: plan.popular ?? false,
+      quotas: plan.quotas,
+      features: plan.features
+    }));
+    void locale;
+    return plans;
+  }
+  async listFeatureRegistry() {
+    if (!this.catalogEntryRepo || !this.projectKey) return this.featureRegistry;
+    let rows;
+    try {
+      rows = await this.catalogEntryRepo.listFeatures({
+        projectKey: this.projectKey
+      });
+    } catch {
+      return this.featureRegistry;
+    }
+    const byKey = new Map(rows.map((r) => [
+      r.featureKey,
+      r
+    ]));
+    const merged = {};
+    for (const [key, meta] of Object.entries(this.featureRegistry)) {
+      const dbIcon = byKey.get(key)?.icon;
+      merged[key] = dbIcon ? {
+        ...meta,
+        icon: dbIcon
+      } : meta;
+    }
+    for (const row of rows) {
+      if (merged[row.featureKey]) continue;
+      merged[row.featureKey] = {
+        label: row.label || row.featureKey,
+        description: row.description ?? "",
+        icon: row.icon ?? "",
+        ...row.plannedOnly ? {
+          plannedOnly: true
+        } : {}
+      };
+    }
+    return merged;
+  }
+  /**
+   * SPEC_V2 §11.1 M6 Pack 2c — public catalog endpoint for bundles
+   * (stem list with live versions). If a `MarketingProjection` with
+   * `targetType=BUNDLE` + matching locale exists, it is merged in.
+   */
+  async listBundles(lang, localeParam = "de") {
+    const locale = lang || localeParam;
+    if (!this.bundleRepo || !this.projectKey) return [];
+    const stems = await this.bundleRepo.list({
+      projectKey: this.projectKey
+    });
+    const requiresIndex = await this.loadFeatureRequiresIndex();
+    const out = [];
+    for (const stem of stems) {
+      const versions = await this.bundleRepo.listVersions(stem.id);
+      const live = versions.find((v) => v.publishedAt !== null && v.supersededAt === null);
+      if (!live) continue;
+      const marketing = await this.lookupMarketing("BUNDLE", live.id, locale);
+      out.push(this.toBundleEntry(stem.bundleKey, live, marketing, requiresIndex));
+    }
+    return out;
+  }
+  /**
+   * `requires` data for `requiresFeatures` (#35) — comes from the
+   * FeatureCatalogEntries. Without a CatalogEntryRepository or on DB errors,
+   * an empty index: the auth-free endpoint must not break on this,
+   * `requiresFeatures` then stays conservatively empty.
+   */
+  async loadFeatureRequiresIndex() {
+    if (!this.catalogEntryRepo || !this.projectKey) return /* @__PURE__ */ new Map();
+    try {
+      const rows = await this.catalogEntryRepo.listFeatures({
+        projectKey: this.projectKey
+      });
+      return buildFeatureRequiresIndex2(rows);
+    } catch {
+      return /* @__PURE__ */ new Map();
+    }
+  }
+  /**
+   * SPEC_V2 §11.1 M6 Pack 2c — public catalog endpoint for BusinessTypes
+   * (stem list with live versions + bundle composition + marketing).
+   */
+  async listBusinessTypes(lang, localeParam = "de") {
+    const locale = lang || localeParam;
+    if (!this.businessTypeRepo || !this.bundleRepo || !this.projectKey) return [];
+    const stems = await this.businessTypeRepo.list({
+      projectKey: this.projectKey
+    });
+    const out = [];
+    for (const stem of stems) {
+      const versions = await this.businessTypeRepo.listVersions(stem.id);
+      const live = versions.find((v) => v.publishedAt !== null && v.supersededAt === null);
+      if (!live) continue;
+      const bundleKeys = [];
+      for (const ref of live.bundles) {
+        const bv = await this.bundleRepo.findVersionById(ref.bundleVersionId);
+        if (bv) bundleKeys.push(bv.bundleKey);
+      }
+      const marketing = await this.lookupMarketing("BUSINESS_TYPE", live.id, locale);
+      out.push({
+        businessTypeVersionId: live.id,
+        businessTypeKey: stem.businessTypeKey,
+        label: stem.label,
+        description: stem.description ?? null,
+        monthlyNet: live.monthlyNet,
+        yearlyNet: live.yearlyNet,
+        bundleKeys,
+        quotaOverrides: live.quotaOverrides,
+        marketing
+      });
+    }
+    return out;
+  }
+  async lookupMarketing(targetType, targetVersionId, locale) {
+    if (!this.marketingRepo || !this.projectKey) return void 0;
+    const rows = await this.marketingRepo.list({
+      projectKey: this.projectKey,
+      targetType,
+      targetVersionId,
+      locale
+    });
+    const row = rows[0];
+    if (!row) return void 0;
+    return {
+      displayLabel: row.displayLabel,
+      description: row.description,
+      visible: row.visible,
+      badge: row.badge,
+      topFeatures: row.topFeatures,
+      trialEnabled: row.trialEnabled,
+      trialDays: row.trialDays,
+      priceTag: row.priceTag,
+      ctaLabel: row.ctaLabel,
+      highlight: row.highlight,
+      priority: row.priority
+    };
+  }
+  toBundleEntry(bundleKey, live, marketing, requiresIndex) {
+    const features = live.features;
+    return {
+      bundleVersionId: live.id,
+      bundleKey,
+      label: live.label,
+      description: null,
+      features,
+      quotas: live.quotas,
+      monthlyNet: live.monthlyNet,
+      yearlyNet: live.yearlyNet,
+      requiresFeatures: collectUnsatisfiedRequires2(features, requiresIndex),
+      marketing
+    };
+  }
+};
+_ts_decorate7([
+  Get("plans"),
+  _ts_param5(0, Query("lang")),
+  _ts_param5(1, Query("locale")),
+  _ts_metadata5("design:type", Function),
+  _ts_metadata5("design:paramtypes", [
+    String,
+    void 0
+  ]),
+  _ts_metadata5("design:returntype", Promise)
+], PublicCatalogController.prototype, "listPlans", null);
+_ts_decorate7([
+  Get("feature-registry"),
+  _ts_metadata5("design:type", Function),
+  _ts_metadata5("design:paramtypes", []),
+  _ts_metadata5("design:returntype", Promise)
+], PublicCatalogController.prototype, "listFeatureRegistry", null);
+_ts_decorate7([
+  Get("bundles"),
+  _ts_param5(0, Query("lang")),
+  _ts_param5(1, Query("locale")),
+  _ts_metadata5("design:type", Function),
+  _ts_metadata5("design:paramtypes", [
+    String,
+    void 0
+  ]),
+  _ts_metadata5("design:returntype", Promise)
+], PublicCatalogController.prototype, "listBundles", null);
+_ts_decorate7([
+  Get("business-types"),
+  _ts_param5(0, Query("lang")),
+  _ts_param5(1, Query("locale")),
+  _ts_metadata5("design:type", Function),
+  _ts_metadata5("design:paramtypes", [
+    String,
+    void 0
+  ]),
+  _ts_metadata5("design:returntype", Promise)
+], PublicCatalogController.prototype, "listBusinessTypes", null);
+PublicCatalogController = _ts_decorate7([
+  Controller2("billing"),
+  _ts_param5(0, Inject5(PLAN_CATALOG_TOKEN)),
+  _ts_param5(1, Inject5(FEATURE_UI_REGISTRY_TOKEN)),
+  _ts_param5(2, Optional3()),
+  _ts_param5(2, Inject5(PUBLIC_CATALOG_PROJECT_KEY_TOKEN)),
+  _ts_param5(3, Optional3()),
+  _ts_param5(3, Inject5(PUBLIC_CATALOG_MARKETING_REPOSITORY_TOKEN)),
+  _ts_param5(4, Optional3()),
+  _ts_param5(4, Inject5(PUBLIC_CATALOG_BUNDLE_REPOSITORY_TOKEN)),
+  _ts_param5(5, Optional3()),
+  _ts_param5(5, Inject5(PUBLIC_CATALOG_BUSINESS_TYPE_REPOSITORY_TOKEN)),
+  _ts_param5(6, Optional3()),
+  _ts_param5(6, Inject5(PUBLIC_CATALOG_CATALOG_ENTRY_REPOSITORY_TOKEN)),
+  _ts_metadata5("design:type", Function),
+  _ts_metadata5("design:paramtypes", [
+    typeof PlanCatalog === "undefined" ? Object : PlanCatalog,
+    typeof FeatureUiRegistry === "undefined" ? Object : FeatureUiRegistry,
+    Object,
+    Object,
+    Object,
+    Object,
+    Object
+  ])
+], PublicCatalogController);
+
+// src/billing/public-catalog.module.ts
+import { Module as Module2 } from "@nestjs/common";
+function _ts_decorate8(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate8, "_ts_decorate");
+var PublicCatalogModule = class _PublicCatalogModule {
+  static {
+    __name(this, "PublicCatalogModule");
+  }
+  static forRoot(options) {
+    const providers = [
+      ...options.extraProviders ?? [],
+      {
+        provide: FEATURE_UI_REGISTRY_TOKEN,
+        useValue: options.featureUiRegistry
+      }
+    ];
+    if (options.projectKey !== void 0) {
+      providers.push({
+        provide: PUBLIC_CATALOG_PROJECT_KEY_TOKEN,
+        useValue: options.projectKey
+      });
+    }
+    if (options.bundleRepository) {
+      providers.push(asProvider(PUBLIC_CATALOG_BUNDLE_REPOSITORY_TOKEN, options.bundleRepository));
+    }
+    if (options.businessTypeRepository) {
+      providers.push(asProvider(PUBLIC_CATALOG_BUSINESS_TYPE_REPOSITORY_TOKEN, options.businessTypeRepository));
+    }
+    if (options.marketingRepository) {
+      providers.push(asProvider(PUBLIC_CATALOG_MARKETING_REPOSITORY_TOKEN, options.marketingRepository));
+    }
+    if (options.catalogEntryRepository) {
+      providers.push(asProvider(PUBLIC_CATALOG_CATALOG_ENTRY_REPOSITORY_TOKEN, options.catalogEntryRepository));
+    }
+    return {
+      module: _PublicCatalogModule,
+      imports: options.imports ?? [],
+      controllers: [
+        PublicCatalogController
+      ],
+      providers,
+      exports: [
+        FEATURE_UI_REGISTRY_TOKEN
+      ]
+    };
+  }
+};
+PublicCatalogModule = _ts_decorate8([
+  Module2({})
+], PublicCatalogModule);
+
+// src/billing/composed-tenant-auth.guard.ts
+import { ForbiddenException as ForbiddenException2, Inject as Inject6, Injectable as Injectable4, Optional as Optional4 } from "@nestjs/common";
+function _ts_decorate9(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate9, "_ts_decorate");
+function _ts_metadata6(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata6, "_ts_metadata");
+function _ts_param6(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param6, "_ts_param");
+var ComposedTenantAuthGuard = class {
+  static {
+    __name(this, "ComposedTenantAuthGuard");
+  }
+  guards;
+  constructor(guards = null) {
+    this.guards = guards;
+  }
+  async canActivate(context) {
+    if (!this.guards || this.guards.length === 0) {
+      throw new ForbiddenException2("TenantBillingModule.forRoot.authGuards ist nicht konfiguriert.");
+    }
+    for (const guard of this.guards) {
+      const result = await Promise.resolve(guard.canActivate(context));
+      if (!result) return false;
+    }
+    return true;
+  }
+};
+ComposedTenantAuthGuard = _ts_decorate9([
+  Injectable4(),
+  _ts_param6(0, Optional4()),
+  _ts_param6(0, Inject6(TENANT_AUTH_GUARDS_TOKEN)),
+  _ts_metadata6("design:type", Function),
+  _ts_metadata6("design:paramtypes", [
+    Object
+  ])
+], ComposedTenantAuthGuard);
+
+// src/billing/tenant-admin.guard.ts
+import { ForbiddenException as ForbiddenException3, Injectable as Injectable5 } from "@nestjs/common";
+function _ts_decorate10(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate10, "_ts_decorate");
+var ADMIN_ROLES = /* @__PURE__ */ new Set([
+  "TENANT_ADMIN",
+  "SUPER_ADMIN"
+]);
+var TenantAdminGuard = class {
+  static {
+    __name(this, "TenantAdminGuard");
+  }
+  canActivate(context) {
+    const request = context.switchToHttp().getRequest();
+    if (!request.user) {
+      throw new ForbiddenException3("Nicht authentifiziert");
+    }
+    const role = request.user.platformRole ?? request.user.role;
+    if (!role || !ADMIN_ROLES.has(role)) {
+      throw new ForbiddenException3("Diese Aktion erfordert die TENANT_ADMIN-Rolle.");
+    }
+    return true;
+  }
+};
+TenantAdminGuard = _ts_decorate10([
+  Injectable5()
+], TenantAdminGuard);
+
+// src/billing/self-service-policy.ts
+var SELF_SERVICE_BLOCKED_PLANS_TOKEN = /* @__PURE__ */ Symbol.for("saas-platform/SelfServiceBlockedPlans");
+var SELF_SERVICE_BLOCKED_BUNDLES_TOKEN = /* @__PURE__ */ Symbol.for("saas-platform/SelfServiceBlockedBundles");
+
+// src/billing/proration.ts
+var DAY_MS = 864e5;
+function computeProration(input) {
+  const { periodStart, periodEnd, now, currentPriceNet, targetPriceNet } = input;
+  const daysInPeriod = Math.max(1, Math.round((periodEnd.getTime() - periodStart.getTime()) / DAY_MS));
+  const daysRemaining = Math.max(0, Math.min(daysInPeriod, Math.round((periodEnd.getTime() - now.getTime()) / DAY_MS)));
+  const prorataDeltaNet = round2((targetPriceNet - currentPriceNet) * daysRemaining / daysInPeriod);
+  return {
+    daysRemainingInPeriod: daysRemaining,
+    daysInPeriod,
+    periodStart,
+    periodEnd,
+    currentPriceNet,
+    targetPriceNet,
+    prorataDeltaNet
+  };
+}
+__name(computeProration, "computeProration");
+function round2(n) {
+  return Math.round(n * 100) / 100;
+}
+__name(round2, "round2");
+
+// src/billing/plan-change-preview.service.ts
+import { Inject as Inject7, Injectable as Injectable6, NotFoundException, Optional as Optional5 } from "@nestjs/common";
+function _ts_decorate11(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate11, "_ts_decorate");
+function _ts_metadata7(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata7, "_ts_metadata");
+function _ts_param7(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param7, "_ts_param");
+var PlanChangePreviewService = class {
+  static {
+    __name(this, "PlanChangePreviewService");
+  }
+  catalog;
+  entitlements;
+  subscriptions;
+  usageSnapshot;
+  blockedPlans;
+  trialProjection;
+  constructor(catalog, entitlements, subscriptions, usageSnapshot, blockedPlans = null, trialProjection = null) {
+    this.catalog = catalog;
+    this.entitlements = entitlements;
+    this.subscriptions = subscriptions;
+    this.usageSnapshot = usageSnapshot;
+    this.blockedPlans = blockedPlans;
+    this.trialProjection = trialProjection;
+  }
+  async preview(tenantId, targetPlan, targetCycle, now = /* @__PURE__ */ new Date()) {
+    const sub = await this.subscriptions.findForTenant(tenantId);
+    if (!sub) {
+      throw new NotFoundException(`Keine Subscription f\xFCr Tenant ${tenantId}`);
+    }
+    const targetPlanDef = findPlan(this.catalog, targetPlan);
+    if (!targetPlanDef) {
+      throw new NotFoundException(`Plan "${targetPlan}" nicht im Catalog (${this.catalog.projectKey})`);
+    }
+    const ctx = {
+      currentPeriodStart: sub.currentPeriodStart,
+      currentPeriodEnd: sub.currentPeriodEnd,
+      trialEndsAt: sub.trialEndsAt,
+      status: sub.status,
+      currentBillingCycle: sub.billingCycle,
+      currentPlan: sub.plan,
+      startedAt: sub.startedAt
+    };
+    const [currentLimits, usage] = await Promise.all([
+      this.entitlements.computeLimits(tenantId, now),
+      this.usageSnapshot.snapshot(tenantId)
+    ]);
+    const currentPlanDef = findPlan(this.catalog, currentLimits.plan);
+    const currentSnap = {
+      id: currentLimits.plan,
+      name: currentPlanDef?.name ?? currentLimits.plan,
+      monthlyNet: getPlanPriceNet(this.catalog, currentLimits.plan, "MONTHLY"),
+      yearlyNet: getPlanPriceNet(this.catalog, currentLimits.plan, "YEARLY"),
+      quotas: currentLimits.quotas,
+      features: Array.from(currentLimits.features).sort()
+    };
+    const targetSnap = {
+      id: targetPlanDef.id,
+      name: targetPlanDef.name ?? targetPlanDef.id,
+      monthlyNet: getPlanPriceNet(this.catalog, targetPlan, "MONTHLY"),
+      yearlyNet: getPlanPriceNet(this.catalog, targetPlan, "YEARLY"),
+      quotas: targetPlanDef.quotas,
+      features: targetPlanDef.features.slice().sort()
+    };
+    const changeType = this.classify(sub.plan, sub.billingCycle, targetPlan, targetCycle);
+    const limitsCheck = {};
+    const quotaKeys = /* @__PURE__ */ new Set([
+      ...Object.keys(currentLimits.quotas),
+      ...Object.keys(targetSnap.quotas),
+      ...Object.keys(usage)
+    ]);
+    for (const key of quotaKeys) {
+      const used = usage[key] ?? 0;
+      const currentMax = currentLimits.quotas[key] ?? 0;
+      const targetMax = targetSnap.quotas[key] ?? 0;
+      const exceeded = targetMax !== -1 && used > targetMax;
+      limitsCheck[key] = {
+        used,
+        currentMax,
+        targetMax,
+        exceeded
+      };
+    }
+    const currentFeatureSet = currentLimits.features;
+    const targetFeatureSet = new Set(targetSnap.features);
+    const featuresLost = Array.from(currentFeatureSet).filter((f) => !targetFeatureSet.has(f)).sort();
+    const featuresGained = targetSnap.features.filter((f) => !currentFeatureSet.has(f));
+    const isImmediate = changeType === "UPGRADE";
+    const effectiveAt = isImmediate ? null : this.resolveEffectiveAt(ctx, now);
+    const proration = isImmediate && ctx.status !== "TRIAL" ? this.computeProration(ctx, now, currentSnap, targetSnap, sub.billingCycle, targetCycle) : null;
+    const blockers = [];
+    const warnings = [];
+    const blockedTargets = this.blockedPlans?.asTarget ?? [];
+    const blockedSources = this.blockedPlans?.asSource ?? [];
+    if (blockedTargets.includes(targetPlan)) {
+      blockers.push({
+        code: `${targetPlan}_NOT_SELF_SERVICE`,
+        message: `${targetSnap.name} wird nur per Sondervertrag aktiviert. Bitte den Vertragsbetreuer kontaktieren.`
+      });
+    }
+    if (blockedSources.includes(sub.plan)) {
+      blockers.push({
+        code: `${sub.plan}_LOCKED`,
+        message: `Aktiver ${currentSnap.name}-Sondervertrag \u2014 bitte den Vertragsbetreuer f\xFCr Plan-Wechsel kontaktieren.`
+      });
+    }
+    for (const [key, row] of Object.entries(limitsCheck)) {
+      if (!row.exceeded) continue;
+      const usedDisplay = isFloatQuota(key) ? row.used.toFixed(1) : row.used.toString();
+      blockers.push({
+        code: `${key.toUpperCase()}_OVER_TARGET`,
+        message: `Aktueller Verbrauch ${usedDisplay} \xFCberschreitet das Ziel-Limit ${row.targetMax} (${key}) im ${targetSnap.name}-Paket. Bitte Verbrauch reduzieren.`
+      });
+    }
+    if (featuresLost.length > 0) {
+      warnings.push({
+        code: "FEATURES_LOST",
+        message: `Mit dem Wechsel verlierst du Zugriff auf ${featuresLost.length} Feature${featuresLost.length === 1 ? "" : "s"}. Bestehende Daten bleiben erhalten und werden nicht gel\xF6scht \u2014 du kannst sie wieder freischalten, wenn du erneut upgradest.`
+      });
+    }
+    if (changeType === "NOOP") {
+      warnings.push({
+        code: "NO_CHANGE",
+        message: "Ziel-Paket und Abrechnungszyklus stimmen mit dem aktuellen Stand \xFCberein."
+      });
+    }
+    const projectedTrialEndsAt = this.trialProjection && sub.status === "TRIAL" ? await this.trialProjection.projectTrialEndsAt({
+      currentPlan: sub.plan,
+      targetPlan,
+      currentTrialEndsAt: sub.trialEndsAt,
+      status: sub.status,
+      now
+    }) : null;
+    return {
+      changeType,
+      current: {
+        plan: currentSnap,
+        billingCycle: sub.billingCycle
+      },
+      target: {
+        plan: targetSnap,
+        billingCycle: targetCycle
+      },
+      effectiveAt,
+      isImmediate,
+      projectedTrialEndsAt,
+      proration,
+      limitsCheck,
+      featuresLost,
+      featuresGained,
+      blockers,
+      warnings
+    };
+  }
+  /** Like `preview`, but only the blocker list — for a server-side
+   * pre-check before the `changePlan` mutation (defense-in-depth). */
+  async assertChangeAllowed(tenantId, targetPlan, targetCycle, now = /* @__PURE__ */ new Date()) {
+    const dto = await this.preview(tenantId, targetPlan, targetCycle, now);
+    return dto.blockers;
+  }
+  classify(currentPlan, currentCycle, targetPlan, targetCycle) {
+    if (currentPlan === targetPlan && currentCycle === targetCycle) return "NOOP";
+    if (currentPlan === targetPlan) return "CYCLE_CHANGE";
+    const currentRank = this.planRank(currentPlan);
+    const targetRank = this.planRank(targetPlan);
+    return targetRank > currentRank ? "UPGRADE" : "DOWNGRADE";
+  }
+  /** Catalog order = rank. Non-marketed plans go to the end. */
+  planRank(planId) {
+    const plans = this.catalog.plans ?? [];
+    const idx = plans.findIndex((p) => p.id === planId);
+    if (idx === -1) return Number.POSITIVE_INFINITY;
+    const plan = plans[idx];
+    if (plan.marketed === false) return Number.POSITIVE_INFINITY - plans.length + idx;
+    return idx;
+  }
+  resolveEffectiveAt(ctx, now) {
+    if (ctx.status === "TRIAL" && ctx.trialEndsAt) return ctx.trialEndsAt;
+    if (ctx.currentPeriodEnd) return ctx.currentPeriodEnd;
+    return periodEndAfter(ctx.startedAt, ctx.currentBillingCycle, now);
+  }
+  computeProration(ctx, now, current, target, currentCycle, targetCycle) {
+    const periodStart = ctx.currentPeriodStart ?? ctx.startedAt ?? now;
+    const periodEnd = ctx.currentPeriodEnd ?? periodEndAfter(ctx.startedAt, ctx.currentBillingCycle, now);
+    return computeProration({
+      periodStart,
+      periodEnd,
+      now,
+      currentPriceNet: priceForCycle(current, currentCycle) ?? 0,
+      targetPriceNet: priceForCycle(target, targetCycle) ?? 0
+    });
+  }
+};
+PlanChangePreviewService = _ts_decorate11([
+  Injectable6(),
+  _ts_param7(0, Inject7(PLAN_CATALOG_TOKEN)),
+  _ts_param7(1, Inject7(EntitlementService)),
+  _ts_param7(2, Inject7(SUBSCRIPTION_USAGE_PORT_TOKEN)),
+  _ts_param7(3, Inject7(USAGE_SNAPSHOT_PORT_TOKEN)),
+  _ts_param7(4, Optional5()),
+  _ts_param7(4, Inject7(SELF_SERVICE_BLOCKED_PLANS_TOKEN)),
+  _ts_param7(5, Optional5()),
+  _ts_param7(5, Inject7(TRIAL_PROJECTION_PORT_TOKEN)),
+  _ts_metadata7("design:type", Function),
+  _ts_metadata7("design:paramtypes", [
+    typeof PlanCatalog === "undefined" ? Object : PlanCatalog,
+    typeof EntitlementService === "undefined" ? Object : EntitlementService,
+    typeof SubscriptionUsagePort === "undefined" ? Object : SubscriptionUsagePort,
+    typeof UsageSnapshotPort === "undefined" ? Object : UsageSnapshotPort,
+    Object,
+    Object
+  ])
+], PlanChangePreviewService);
+function priceForCycle(snap, cycle) {
+  return cycle === "YEARLY" ? snap.yearlyNet : snap.monthlyNet;
+}
+__name(priceForCycle, "priceForCycle");
+function isFloatQuota(key) {
+  return key.toLowerCase().includes("storage");
+}
+__name(isFloatQuota, "isFloatQuota");
+
+// src/billing/pending-plan-materialization.service.ts
+import { Inject as Inject8, Injectable as Injectable7, Logger as Logger3, Optional as Optional6 } from "@nestjs/common";
+
+// src/billing/contract-freeze.tokens.ts
+var CONTRACT_FREEZE_PORT_TOKEN = /* @__PURE__ */ Symbol.for("saas-platform/ContractFreezePort");
+var CONTRACT_FREEZE_SOURCE_PORT_TOKEN = /* @__PURE__ */ Symbol.for("saas-platform/ContractFreezeSourcePort");
+var CONTRACT_FREEZE_PROJECT_KEY_TOKEN = /* @__PURE__ */ Symbol.for("saas-platform/ContractFreezeProjectKey");
+
+// src/billing/pending-plan-materialization.service.ts
+function _ts_decorate12(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate12, "_ts_decorate");
+function _ts_metadata8(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata8, "_ts_metadata");
+function _ts_param8(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param8, "_ts_param");
+var PendingPlanMaterializationService = class _PendingPlanMaterializationService {
+  static {
+    __name(this, "PendingPlanMaterializationService");
+  }
+  query;
+  subscriptionWrite;
+  entitlements;
+  contractFreeze;
+  logger = new Logger3(_PendingPlanMaterializationService.name);
+  constructor(query, subscriptionWrite, entitlements, contractFreeze = null) {
+    this.query = query;
+    this.subscriptionWrite = subscriptionWrite;
+    this.entitlements = entitlements;
+    this.contractFreeze = contractFreeze;
+  }
+  async materializeDuePlanChanges(now = /* @__PURE__ */ new Date()) {
+    const due = await this.query.findDuePendingPlanChanges(now);
+    let applied = 0;
+    for (const change of due) {
+      const cycle = change.pendingBillingCycle ?? "MONTHLY";
+      const period = initialPeriodWindow(now, cycle);
+      try {
+        await this.subscriptionWrite.changePlanImmediate(change.tenantId, {
+          planId: change.pendingPlan,
+          cycle,
+          periodStart: period.start,
+          periodEnd: period.end,
+          // Status stays (ACTIVE/PAST_DUE etc.) — only the plan is materialized.
+          nextStatus: null
+        });
+        this.entitlements.invalidateTenant(change.tenantId);
+        applied += 1;
+      } catch (err) {
+        this.logger.error(`Pending-Plan-Materialisierung fehlgeschlagen (tenant ${change.tenantId}): ${String(err)}`);
+        continue;
+      }
+      await this.tryFreeze(change.tenantId, change.pendingPlan, cycle, now);
+    }
+    if (applied > 0) {
+      this.logger.log(`Pending-Plan-Materialisierung: ${applied} geplante(r) Plan-Wechsel angewandt.`);
+    }
+    return {
+      applied
+    };
+  }
+  async tryFreeze(tenantId, plan, cycle, now) {
+    if (!this.contractFreeze) return;
+    try {
+      await this.contractFreeze.freezeOnPlanChange(tenantId, plan, cycle, now);
+    } catch (err) {
+      this.logger.error(`Contract-Freeze nach Materialisierung fehlgeschlagen (tenant ${tenantId}): ${String(err)}`);
+    }
+  }
+};
+PendingPlanMaterializationService = _ts_decorate12([
+  Injectable7(),
+  _ts_param8(0, Inject8(PENDING_PLAN_QUERY_PORT_TOKEN)),
+  _ts_param8(1, Inject8(SUBSCRIPTION_WRITE_PORT_TOKEN)),
+  _ts_param8(3, Optional6()),
+  _ts_param8(3, Inject8(CONTRACT_FREEZE_PORT_TOKEN)),
+  _ts_metadata8("design:type", Function),
+  _ts_metadata8("design:paramtypes", [
+    typeof PendingPlanQueryPort === "undefined" ? Object : PendingPlanQueryPort,
+    typeof TenantSubscriptionWritePort === "undefined" ? Object : TenantSubscriptionWritePort,
+    typeof EntitlementService === "undefined" ? Object : EntitlementService,
+    Object
+  ])
+], PendingPlanMaterializationService);
+
+// src/billing/subscription-contract-freeze.service.ts
+import { Inject as Inject9, Injectable as Injectable8 } from "@nestjs/common";
+function _ts_decorate13(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate13, "_ts_decorate");
+function _ts_metadata9(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata9, "_ts_metadata");
+function _ts_param9(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param9, "_ts_param");
+var SubscriptionContractFreezeService = class {
+  static {
+    __name(this, "SubscriptionContractFreezeService");
+  }
+  catalog;
+  entitlements;
+  contracts;
+  projectKey;
+  source;
+  constructor(catalog, entitlements, contracts, projectKey, source) {
+    this.catalog = catalog;
+    this.entitlements = entitlements;
+    this.contracts = contracts;
+    this.projectKey = projectKey;
+    this.source = source;
+  }
+  async freezeOnPlanChange(tenantId, newPlan, billingCycle, effectiveFrom) {
+    const cycle = billingCycle === "YEARLY" ? "yearly" : "monthly";
+    const vatRate = this.catalog.vatRate;
+    const bundles = await this.source.loadBookedBundles(tenantId, cycle, vatRate);
+    const livePlanVersionId = await this.source.findLivePlanVersionId(newPlan);
+    const previous = await this.contracts.findActiveByTenantId(tenantId, effectiveFrom);
+    if (previous) {
+      await this.contracts.terminate(previous.id, {
+        effectiveUntil: effectiveFrom,
+        status: "superseded"
+      });
+    }
+    this.entitlements.invalidateTenant(tenantId);
+    const limits = await this.entitlements.computeLimits(tenantId, effectiveFrom);
+    const planDef = findPlan(this.catalog, newPlan);
+    const planPriceNet = getPlanPriceNet(this.catalog, newPlan, billingCycle) ?? 0;
+    const planLineItem = {
+      kind: "plan",
+      sourceKey: newPlan,
+      sourceVersionId: livePlanVersionId,
+      titleSnapshot: planDef?.name ?? newPlan,
+      descriptionSnapshot: planDef?.tagline ?? null,
+      quantity: 1,
+      unit: null,
+      priceNet: planPriceNet,
+      priceGross: round22(planPriceNet * (1 + vatRate / 100)),
+      billingCycle: cycle,
+      minimumTermUntil: null,
+      featuresSnapshot: planDef?.features ?? [],
+      quotaEffectsSnapshot: planDef?.quotas ?? {},
+      metadata: null
+    };
+    const lineItems = [
+      planLineItem,
+      ...bundles.lineItems
+    ];
+    const subtotalNet = round22(lineItems.reduce((sum, li) => sum + li.priceNet, 0));
+    const data = {
+      projectKey: this.projectKey,
+      tenantId,
+      status: "active",
+      effectiveFrom,
+      effectiveUntil: null,
+      originalPlanVersionId: livePlanVersionId,
+      originalBundleVersionIds: bundles.bundleVersionIds,
+      entitlementSnapshot: {
+        plan: limits.plan,
+        quotas: {
+          ...limits.quotas
+        },
+        features: [
+          ...limits.features
+        ]
+      },
+      priceSnapshot: {
+        currency: this.catalog.currency,
+        billingCycle: cycle,
+        subtotalNet,
+        discountNet: 0,
+        totalNet: subtotalNet,
+        vatRate,
+        totalGross: round22(subtotalNet * (1 + vatRate / 100))
+      },
+      lineItems
+    };
+    await this.contracts.create(data);
+    this.entitlements.invalidateTenant(tenantId);
+  }
+};
+SubscriptionContractFreezeService = _ts_decorate13([
+  Injectable8(),
+  _ts_param9(0, Inject9(PLAN_CATALOG_TOKEN)),
+  _ts_param9(1, Inject9(EntitlementService)),
+  _ts_param9(2, Inject9(SubscriptionContractService)),
+  _ts_param9(3, Inject9(CONTRACT_FREEZE_PROJECT_KEY_TOKEN)),
+  _ts_param9(4, Inject9(CONTRACT_FREEZE_SOURCE_PORT_TOKEN)),
+  _ts_metadata9("design:type", Function),
+  _ts_metadata9("design:paramtypes", [
+    typeof PlanCatalog === "undefined" ? Object : PlanCatalog,
+    typeof EntitlementService === "undefined" ? Object : EntitlementService,
+    typeof SubscriptionContractService === "undefined" ? Object : SubscriptionContractService,
+    String,
+    typeof ContractFreezeSourcePort === "undefined" ? Object : ContractFreezeSourcePort
+  ])
+], SubscriptionContractFreezeService);
+function round22(value) {
+  return Math.round(value * 100) / 100;
+}
+__name(round22, "round2");
+
+// src/billing/trial-carryover.ts
+var MS_PER_DAY = 864e5;
+function computeCarriedTrialEndsAt(currentTrialDays, newTrialDays, currentTrialEndsAt, now) {
+  const daysRemaining = Math.max(0, Math.ceil((currentTrialEndsAt.getTime() - now.getTime()) / MS_PER_DAY));
+  const usedDays = Math.max(0, currentTrialDays - daysRemaining);
+  const newDays = Math.max(0, newTrialDays - usedDays);
+  return new Date(now.getTime() + newDays * MS_PER_DAY);
+}
+__name(computeCarriedTrialEndsAt, "computeCarriedTrialEndsAt");
+
+// src/billing/dto/tenant-billing.dto.ts
+import { IsBoolean as IsBoolean2, IsOptional as IsOptional2, IsString as IsString2, Matches } from "class-validator";
+function _ts_decorate14(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate14, "_ts_decorate");
+function _ts_metadata10(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata10, "_ts_metadata");
+var PLAN_OR_CYCLE_PATTERN = /^[A-Z][A-Z0-9_]*$/;
+var PreviewPlanChangeDto = class {
+  static {
+    __name(this, "PreviewPlanChangeDto");
+  }
+  plan;
+  billingCycle;
+};
+_ts_decorate14([
+  IsString2(),
+  Matches(PLAN_OR_CYCLE_PATTERN, {
+    message: "plan muss SCREAMING_SNAKE_CASE sein"
+  }),
+  _ts_metadata10("design:type", String)
+], PreviewPlanChangeDto.prototype, "plan", void 0);
+_ts_decorate14([
+  IsString2(),
+  Matches(PLAN_OR_CYCLE_PATTERN, {
+    message: "billingCycle muss SCREAMING_SNAKE_CASE sein (z. B. MONTHLY, YEARLY)"
+  }),
+  _ts_metadata10("design:type", String)
+], PreviewPlanChangeDto.prototype, "billingCycle", void 0);
+var ChangePlanDto = class extends PreviewPlanChangeDto {
+  static {
+    __name(this, "ChangePlanDto");
+  }
+  /** Immediate change (true) vs. change at period end (false/undefined). */
+  effectiveImmediately;
+};
+_ts_decorate14([
+  IsOptional2(),
+  IsBoolean2(),
+  _ts_metadata10("design:type", Boolean)
+], ChangePlanDto.prototype, "effectiveImmediately", void 0);
+var CancelSubscriptionDto = class {
+  static {
+    __name(this, "CancelSubscriptionDto");
+  }
+  /** true = cancel immediately (status CANCELED). false/undefined = at period end. */
+  immediately;
+};
+_ts_decorate14([
+  IsOptional2(),
+  IsBoolean2(),
+  _ts_metadata10("design:type", Boolean)
+], CancelSubscriptionDto.prototype, "immediately", void 0);
+
+// src/billing/dto/onboarding-subscription.dto.ts
+import { ArrayMaxSize, IsArray, IsOptional as IsOptional3, IsString as IsString3, IsUUID, Matches as Matches2 } from "class-validator";
+function _ts_decorate15(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate15, "_ts_decorate");
+function _ts_metadata11(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata11, "_ts_metadata");
+var PLAN_OR_CYCLE_PATTERN2 = /^[A-Z][A-Z0-9_]*$/;
+var PROMO_CODE_PATTERN = /^[A-Z0-9_-]{4,32}$/i;
+var CompleteOnboardingSubscriptionDto = class {
+  static {
+    __name(this, "CompleteOnboardingSubscriptionDto");
+  }
+  plan;
+  billingCycle;
+  promoCode;
+  /**
+   * Optional — UUIDs of the BundleVersions that should be booked
+   * together with the plan (P11.7.3). Per bundle, the platform
+   * default minimum term (12 months) is set. Bundles are added
+   * best-effort **after** the plan change — an error on an individual
+   * bundle (e.g. incompatible with the chosen plan) lands as a
+   * warning in the response, without rolling back the plan change.
+   */
+  bundleVersionIds;
+};
+_ts_decorate15([
+  IsString3(),
+  Matches2(PLAN_OR_CYCLE_PATTERN2, {
+    message: "plan muss SCREAMING_SNAKE_CASE sein"
+  }),
+  _ts_metadata11("design:type", String)
+], CompleteOnboardingSubscriptionDto.prototype, "plan", void 0);
+_ts_decorate15([
+  IsString3(),
+  Matches2(PLAN_OR_CYCLE_PATTERN2, {
+    message: "billingCycle muss SCREAMING_SNAKE_CASE sein (z. B. MONTHLY, YEARLY)"
+  }),
+  _ts_metadata11("design:type", String)
+], CompleteOnboardingSubscriptionDto.prototype, "billingCycle", void 0);
+_ts_decorate15([
+  IsOptional3(),
+  IsString3(),
+  Matches2(PROMO_CODE_PATTERN, {
+    message: 'promoCode muss aus A\u2013Z, 0\u20139, "-", "_" bestehen (4\u201332 Zeichen)'
+  }),
+  _ts_metadata11("design:type", String)
+], CompleteOnboardingSubscriptionDto.prototype, "promoCode", void 0);
+_ts_decorate15([
+  IsOptional3(),
+  IsArray(),
+  ArrayMaxSize(10),
+  IsUUID("all", {
+    each: true
+  }),
+  _ts_metadata11("design:type", Array)
+], CompleteOnboardingSubscriptionDto.prototype, "bundleVersionIds", void 0);
+
+// src/billing/tenant-billing.controller.ts
+import { BadRequestException, Body as Body2, Controller as Controller3, ForbiddenException as ForbiddenException4, Get as Get2, HttpCode, HttpStatus as HttpStatus2, Inject as Inject11, Logger as Logger4, NotFoundException as NotFoundException3, Optional as Optional8, Post as Post2, Req, UseGuards as UseGuards2 } from "@nestjs/common";
+
+// src/billing/subscription-bundles.service.ts
+import { Inject as Inject10, Injectable as Injectable9, NotFoundException as NotFoundException2, Optional as Optional7, UnprocessableEntityException } from "@nestjs/common";
+function _ts_decorate16(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate16, "_ts_decorate");
+function _ts_metadata12(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata12, "_ts_metadata");
+function _ts_param10(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param10, "_ts_param");
+var SubscriptionBundlesService = class {
+  static {
+    __name(this, "SubscriptionBundlesService");
+  }
+  repo;
+  bundles;
+  blockedBundles;
+  defaultMinTermMonths;
+  constructor(repo, bundles, config = {}, blockedBundles = null) {
+    this.repo = repo;
+    this.bundles = bundles;
+    this.blockedBundles = blockedBundles;
+    this.defaultMinTermMonths = config.defaultMinimumTermMonths ?? 12;
+  }
+  /** All bundle bookings of a subscription (for the "My Bundles" page). */
+  async listForSubscription(subscriptionId) {
+    const records = await this.repo.listBySubscription(subscriptionId);
+    return Promise.all(records.map(async (r) => {
+      const bv = await this.bundles.findVersionById(r.bundleVersionId);
+      return {
+        ...r,
+        bundleKey: bv?.bundleKey ?? null,
+        label: bv?.label ?? null,
+        monthlyNet: bv?.monthlyNet ?? null
+      };
+    }));
+  }
+  async addBundleToSubscription(input) {
+    const bundleVersion = await this.bundles.findVersionById(input.bundleVersionId);
+    if (!bundleVersion) {
+      throw new NotFoundException2(`BundleVersion '${input.bundleVersionId}' nicht gefunden`);
+    }
+    if (bundleVersion.publishedAt === null) {
+      throw new UnprocessableEntityException({
+        code: "BUNDLE_VERSION_NOT_PUBLISHED",
+        message: `BundleVersion '${input.bundleVersionId}' ist nicht published und kann nicht gebucht werden.`
+      });
+    }
+    if (bundleVersion.supersededAt !== null) {
+      throw new UnprocessableEntityException({
+        code: "BUNDLE_VERSION_SUPERSEDED",
+        message: `BundleVersion '${input.bundleVersionId}' wurde durch eine Nachfolge-Version abgel\xF6st.`
+      });
+    }
+    if (this.blockedBundles?.bundleKeys?.includes(bundleVersion.bundleKey)) {
+      throw new UnprocessableEntityException({
+        code: "BUNDLE_NOT_SELF_SERVICE",
+        message: `Bundle '${bundleVersion.bundleKey}' wird nur per Sondervertrag aktiviert. Bitte den Vertragsbetreuer kontaktieren.`
+      });
+    }
+    const planIds = bundleVersion.compatibility?.planIds ?? [];
+    if (planIds.length > 0 && !planIds.includes(input.currentPlanKey)) {
+      throw new UnprocessableEntityException({
+        code: "BUNDLE_INCOMPATIBLE_WITH_PLAN",
+        message: `BundleVersion '${input.bundleVersionId}' ist nicht mit Plan '${input.currentPlanKey}' kompatibel. Erlaubt: [${planIds.join(", ")}].`
+      });
+    }
+    const active = await this.repo.listActiveBySubscription(input.subscriptionId);
+    if (active.some((b) => b.bundleVersionId === input.bundleVersionId)) {
+      throw new UnprocessableEntityException({
+        code: "BUNDLE_ALREADY_SUBSCRIBED",
+        message: `Subscription '${input.subscriptionId}' hat dieses Bundle bereits aktiv gebucht.`
+      });
+    }
+    const startedAt = input.startedAt ?? /* @__PURE__ */ new Date();
+    const minimumTermMonths = input.minimumTermMonths ?? this.defaultMinTermMonths;
+    const minimumTermEndsAt = minimumTermMonths > 0 ? addMonths(startedAt, minimumTermMonths) : null;
+    return this.repo.add({
+      subscriptionId: input.subscriptionId,
+      bundleVersionId: input.bundleVersionId,
+      startedAt,
+      minimumTermEndsAt
+    });
+  }
+  async cancelBundleFromSubscription(input) {
+    const existing = await this.repo.findById(input.subscriptionBundleId);
+    if (!existing) {
+      throw new NotFoundException2(`SubscriptionBundle '${input.subscriptionBundleId}' nicht gefunden`);
+    }
+    if (existing.canceledAt !== null) {
+      throw new UnprocessableEntityException({
+        code: "SUBSCRIPTION_BUNDLE_ALREADY_CANCELED",
+        message: `SubscriptionBundle '${input.subscriptionBundleId}' ist bereits gek\xFCndigt.`
+      });
+    }
+    const canceledAt = input.canceledAt ?? /* @__PURE__ */ new Date();
+    const canceledEffectiveAt = resolveBundleCancelEffectiveAt({
+      canceledAt,
+      currentPeriodEnd: input.currentPeriodEnd ?? null,
+      minimumTermEndsAt: existing.minimumTermEndsAt
+    });
+    return this.repo.cancel(input.subscriptionBundleId, {
+      canceledAt,
+      canceledEffectiveAt
+    });
+  }
+  /**
+   * "Undo cancellation" — only as long as the cancellation is not yet effective
+   * (the bundle runs until `canceledEffectiveAt`). After that, re-booking is the way.
+   */
+  async reactivateBundle(subscriptionBundleId) {
+    const existing = await this.repo.findById(subscriptionBundleId);
+    if (!existing) {
+      throw new NotFoundException2(`SubscriptionBundle '${subscriptionBundleId}' nicht gefunden`);
+    }
+    if (existing.canceledAt === null) {
+      throw new UnprocessableEntityException({
+        code: "SUBSCRIPTION_BUNDLE_NOT_CANCELED",
+        message: `SubscriptionBundle '${subscriptionBundleId}' ist nicht gek\xFCndigt.`
+      });
+    }
+    if (existing.canceledEffectiveAt !== null && existing.canceledEffectiveAt <= /* @__PURE__ */ new Date()) {
+      throw new UnprocessableEntityException({
+        code: "SUBSCRIPTION_BUNDLE_CANCELLATION_EFFECTIVE",
+        message: "K\xFCndigung bereits wirksam \u2014 bitte das Bundle neu buchen."
+      });
+    }
+    return this.repo.reactivate(subscriptionBundleId);
+  }
+};
+SubscriptionBundlesService = _ts_decorate16([
+  Injectable9(),
+  _ts_param10(0, Inject10(SUBSCRIPTION_BUNDLE_REPOSITORY_TOKEN)),
+  _ts_param10(1, Inject10(BUNDLE_REPOSITORY_TOKEN)),
+  _ts_param10(2, Optional7()),
+  _ts_param10(2, Inject10(SUBSCRIPTION_BUNDLE_CONFIG_TOKEN)),
+  _ts_param10(3, Optional7()),
+  _ts_param10(3, Inject10(SELF_SERVICE_BLOCKED_BUNDLES_TOKEN)),
+  _ts_metadata12("design:type", Function),
+  _ts_metadata12("design:paramtypes", [
+    typeof SubscriptionBundleRepository === "undefined" ? Object : SubscriptionBundleRepository,
+    typeof BundleRepository === "undefined" ? Object : BundleRepository,
+    typeof SubscriptionBundleConfig === "undefined" ? Object : SubscriptionBundleConfig,
+    Object
+  ])
+], SubscriptionBundlesService);
+function resolveBundleCancelEffectiveAt(input) {
+  const periodEnd = input.currentPeriodEnd ?? input.canceledAt;
+  const minTermEnd = input.minimumTermEndsAt ?? input.canceledAt;
+  return periodEnd.getTime() >= minTermEnd.getTime() ? periodEnd : minTermEnd;
+}
+__name(resolveBundleCancelEffectiveAt, "resolveBundleCancelEffectiveAt");
+function addMonths(date, months) {
+  const out = new Date(date.getTime());
+  out.setUTCMonth(out.getUTCMonth() + months);
+  return out;
+}
+__name(addMonths, "addMonths");
+
+// src/billing/tenant-billing.controller.ts
+function _ts_decorate17(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate17, "_ts_decorate");
+function _ts_metadata13(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata13, "_ts_metadata");
+function _ts_param11(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param11, "_ts_param");
+var TenantBillingController = class _TenantBillingController {
+  static {
+    __name(this, "TenantBillingController");
+  }
+  entitlements;
+  planPreview;
+  subscriptionUsage;
+  usageSnapshot;
+  subscriptionWrite;
+  tenantIdResolver;
+  userIdResolver;
+  blockedPlans;
+  promoCodes;
+  auditService;
+  userEmailResolver;
+  auditContextResolver;
+  subscriptionBundles;
+  contractFreeze;
+  trialProjection;
+  constructor(entitlements, planPreview, subscriptionUsage, usageSnapshot, subscriptionWrite, tenantIdResolver = null, userIdResolver = null, blockedPlans = null, promoCodes = null, auditService = null, userEmailResolver = null, auditContextResolver = null, subscriptionBundles = null, contractFreeze = null, trialProjection = null) {
+    this.entitlements = entitlements;
+    this.planPreview = planPreview;
+    this.subscriptionUsage = subscriptionUsage;
+    this.usageSnapshot = usageSnapshot;
+    this.subscriptionWrite = subscriptionWrite;
+    this.tenantIdResolver = tenantIdResolver;
+    this.userIdResolver = userIdResolver;
+    this.blockedPlans = blockedPlans;
+    this.promoCodes = promoCodes;
+    this.auditService = auditService;
+    this.userEmailResolver = userEmailResolver;
+    this.auditContextResolver = auditContextResolver;
+    this.subscriptionBundles = subscriptionBundles;
+    this.contractFreeze = contractFreeze;
+    this.trialProjection = trialProjection;
+  }
+  logger = new Logger4(_TenantBillingController.name);
+  // ---------------------------------------------------------------------
+  // Reads (Phase B) — all authenticated tenant users
+  // ---------------------------------------------------------------------
+  async getEntitlement(req) {
+    const tenantId = this.requireTenantId(req);
+    const limits = await this.entitlements.computeLimits(tenantId);
+    return toEffectiveLimitsSnapshot(limits);
+  }
+  async getUsage(req) {
+    const tenantId = this.requireTenantId(req);
+    const [sub, limits, usageRaw] = await Promise.all([
+      this.subscriptionUsage.findForTenant(tenantId),
+      this.entitlements.computeLimits(tenantId),
+      this.usageSnapshot.snapshot(tenantId)
+    ]);
+    if (!sub) {
+      throw new NotFoundException3(`Keine Subscription f\xFCr Tenant ${tenantId}`);
+    }
+    const usage = {};
+    for (const key of /* @__PURE__ */ new Set([
+      ...Object.keys(limits.quotas),
+      ...Object.keys(usageRaw)
+    ])) {
+      usage[key] = usageRaw[key] ?? 0;
+    }
+    return {
+      plan: sub.plan,
+      effectivePlan: limits.plan,
+      billingCycle: sub.billingCycle,
+      status: sub.status,
+      isPilot: sub.isPilot,
+      pilotEndsAt: sub.pilotEndsAt,
+      trialEndsAt: sub.trialEndsAt,
+      startedAt: sub.startedAt,
+      currentPeriodStart: sub.currentPeriodStart,
+      currentPeriodEnd: sub.currentPeriodEnd,
+      pendingPlan: sub.pendingPlan,
+      pendingBillingCycle: sub.pendingBillingCycle,
+      pendingEffectiveAt: sub.pendingEffectiveAt,
+      planVersion: sub.planVersion,
+      pendingPlanVersion: sub.pendingPlanVersion,
+      pendingPlanVersionEffectiveAt: sub.pendingPlanVersionEffectiveAt,
+      pendingPlanVersionAccepted: sub.pendingPlanVersionAccepted,
+      pendingPlanVersionAcceptedAt: sub.pendingPlanVersionAcceptedAt,
+      limits: toEffectiveLimitsSnapshot(limits),
+      usage,
+      packageSnapshot: sub.packageSnapshot ?? null,
+      checkoutOfferId: sub.checkoutOfferId ?? null
+    };
+  }
+  // ---------------------------------------------------------------------
+  // Plan preview (Phase C, read-only) — TENANT_ADMIN
+  // ---------------------------------------------------------------------
+  async previewPlanChange(req, dto) {
+    const tenantId = this.requireTenantId(req);
+    return this.planPreview.preview(tenantId, dto.plan, dto.billingCycle);
+  }
+  // ---------------------------------------------------------------------
+  // Plan change — TENANT_ADMIN (cost-relevant)
+  // ---------------------------------------------------------------------
+  async changePlan(req, dto) {
+    const tenantId = this.requireTenantId(req);
+    const userId = this.requireUserId(req);
+    const blockedTargets = this.blockedPlans?.asTarget ?? [];
+    if (blockedTargets.includes(dto.plan)) {
+      throw new ForbiddenException4(`${dto.plan} wird nicht per Self-Service aktiviert.`);
+    }
+    const sub = await this.subscriptionUsage.findForTenant(tenantId);
+    if (!sub) throw new NotFoundException3(`Keine Subscription f\xFCr Tenant ${tenantId}`);
+    const blockers = await this.planPreview.assertChangeAllowed(tenantId, dto.plan, dto.billingCycle);
+    if (blockers.length > 0) {
+      throw new BadRequestException({
+        message: "Plan-Wechsel blockiert.",
+        blockers
+      });
+    }
+    if (dto.effectiveImmediately) {
+      const wasTrial = sub.status === "TRIAL";
+      const period = wasTrial ? null : initialPeriodWindow(/* @__PURE__ */ new Date(), dto.billingCycle);
+      const trialEndsAt = wasTrial && this.trialProjection ? await this.trialProjection.projectTrialEndsAt({
+        currentPlan: sub.plan,
+        targetPlan: dto.plan,
+        currentTrialEndsAt: sub.trialEndsAt,
+        status: sub.status,
+        now: /* @__PURE__ */ new Date()
+      }) : void 0;
+      const result = await this.subscriptionWrite.changePlanImmediate(tenantId, {
+        planId: dto.plan,
+        cycle: dto.billingCycle,
+        periodStart: period?.start ?? null,
+        periodEnd: period?.end ?? null,
+        nextStatus: wasTrial ? null : "ACTIVE",
+        trialEndsAt
+      });
+      this.entitlements.invalidateTenant(tenantId);
+      await this.tryFreezeOnPlanChange(tenantId, dto.plan, dto.billingCycle, wasTrial);
+      await this.auditLog(req, userId, "Subscription", tenantId, "CHANGE_PLAN", {
+        fromPlan: sub.plan,
+        fromCycle: sub.billingCycle,
+        toPlan: result.plan,
+        toCycle: result.billingCycle,
+        immediate: true
+      });
+      return {
+        plan: result.plan,
+        billingCycle: result.billingCycle,
+        immediate: true
+      };
+    }
+    const effectiveAt = sub.status === "TRIAL" && sub.trialEndsAt ? sub.trialEndsAt : sub.currentPeriodEnd ?? /* @__PURE__ */ new Date();
+    await this.subscriptionWrite.schedulePlanChange(tenantId, {
+      pendingPlan: dto.plan,
+      pendingBillingCycle: dto.billingCycle,
+      pendingEffectiveAt: effectiveAt
+    });
+    this.entitlements.invalidateTenant(tenantId);
+    await this.auditLog(req, userId, "Subscription", tenantId, "SCHEDULE_PLAN_CHANGE", {
+      fromPlan: sub.plan,
+      fromCycle: sub.billingCycle,
+      pendingPlan: dto.plan,
+      pendingCycle: dto.billingCycle,
+      effectiveAt: effectiveAt.toISOString()
+    });
+    return {
+      plan: sub.plan,
+      billingCycle: sub.billingCycle,
+      pendingPlan: dto.plan,
+      pendingBillingCycle: dto.billingCycle,
+      pendingEffectiveAt: effectiveAt,
+      immediate: false
+    };
+  }
+  // ---------------------------------------------------------------------
+  // Onboarding — initial subscription from the configurator step
+  // ---------------------------------------------------------------------
+  async completeOnboardingSubscription(req, dto) {
+    const tenantId = this.requireTenantId(req);
+    const userId = this.requireUserId(req);
+    const userEmail = this.resolveUserEmail(req);
+    const warnings = [];
+    const blockedTargets = this.blockedPlans?.asTarget ?? [];
+    if (blockedTargets.includes(dto.plan)) {
+      throw new ForbiddenException4(`${dto.plan} wird nicht per Self-Service aktiviert.`);
+    }
+    const sub = await this.subscriptionUsage.findForTenant(tenantId);
+    if (!sub) throw new NotFoundException3(`Keine Subscription f\xFCr Tenant ${tenantId}`);
+    const blockers = await this.planPreview.assertChangeAllowed(tenantId, dto.plan, dto.billingCycle);
+    if (blockers.length > 0) {
+      throw new BadRequestException({
+        message: "Plan-Wechsel im Onboarding blockiert.",
+        blockers
+      });
+    }
+    const wasTrial = sub.status === "TRIAL";
+    const period = wasTrial ? null : initialPeriodWindow(/* @__PURE__ */ new Date(), dto.billingCycle);
+    const canRedeem = !!dto.promoCode && !!this.promoCodes && !!sub.id;
+    const redeemPromoCallback = canRedeem ? async (tx, subscriptionId) => this.promoCodes.redeemInTransaction({
+      code: dto.promoCode,
+      subscriptionId,
+      tenantId,
+      email: userEmail ?? void 0
+    }, tx) : null;
+    let planResult;
+    let promoRedemption = null;
+    if (this.subscriptionWrite.applyOnboardingSelection) {
+      try {
+        const result = await this.subscriptionWrite.applyOnboardingSelection(tenantId, {
+          planId: dto.plan,
+          cycle: dto.billingCycle,
+          periodStart: period?.start ?? null,
+          periodEnd: period?.end ?? null,
+          nextStatus: wasTrial ? null : "ACTIVE"
+        }, redeemPromoCallback);
+        planResult = {
+          plan: result.plan,
+          billingCycle: result.billingCycle
+        };
+        if (result.promoRedemption) {
+          promoRedemption = this.toResponseRedemption(result.promoRedemption, dto.promoCode);
+        } else if (dto.promoCode) {
+          warnings.push(...this.collectPromoSkipReasons(dto.promoCode, sub));
+        }
+      } catch (err) {
+        throw new BadRequestException({
+          message: err instanceof Error ? `Onboarding-Anlage fehlgeschlagen: ${err.message}` : "Onboarding-Anlage fehlgeschlagen"
+        });
+      }
+    } else {
+      planResult = await this.subscriptionWrite.changePlanImmediate(tenantId, {
+        planId: dto.plan,
+        cycle: dto.billingCycle,
+        periodStart: period?.start ?? null,
+        periodEnd: period?.end ?? null,
+        nextStatus: wasTrial ? null : "ACTIVE"
+      });
+      await this.tryFreezeOnPlanChange(tenantId, dto.plan, dto.billingCycle, wasTrial);
+      if (dto.promoCode) {
+        if (!this.promoCodes) {
+          warnings.push("Promo-Code wurde gesendet, aber PromoCodesModule ist nicht geladen \u2014 der Code wurde NICHT eingel\xF6st.");
+        } else if (!sub.id) {
+          warnings.push("Promo-Code wurde gesendet, aber der Adapter liefert keine SubscriptionUsageRecord.id \u2014 der Code wurde NICHT eingel\xF6st.");
+        } else {
+          try {
+            const redemption = await this.promoCodes.redeem({
+              code: dto.promoCode,
+              subscriptionId: sub.id,
+              tenantId,
+              email: userEmail ?? void 0
+            });
+            promoRedemption = this.toResponseRedemption(redemption, dto.promoCode);
+          } catch (err) {
+            const message = err instanceof Error ? err.message : "Unbekannter Fehler";
+            warnings.push(`Promo-Code konnte nicht eingel\xF6st werden: ${message}`);
+          }
+        }
+      }
+    }
+    this.entitlements.invalidateTenant(tenantId);
+    await this.auditLog(req, userId, "Subscription", tenantId, "COMPLETE_ONBOARDING_SUBSCRIPTION", {
+      plan: planResult.plan,
+      billingCycle: planResult.billingCycle,
+      promoCode: dto.promoCode ?? null,
+      promoRedeemed: promoRedemption != null,
+      warnings
+    });
+    const bundleVersionIds = dto.bundleVersionIds ?? [];
+    let bundlesAdded = 0;
+    if (bundleVersionIds.length > 0 && this.subscriptionBundles && sub.id) {
+      for (const bundleVersionId of bundleVersionIds) {
+        try {
+          await this.subscriptionBundles.addBundleToSubscription({
+            subscriptionId: sub.id,
+            bundleVersionId,
+            currentPlanKey: planResult.plan
+          });
+          bundlesAdded += 1;
+        } catch (err) {
+          warnings.push(`Bundle '${bundleVersionId}' konnte nicht gebucht werden: ` + (err instanceof Error ? err.message : String(err)));
+        }
+      }
+    } else if (bundleVersionIds.length > 0 && !this.subscriptionBundles) {
+      warnings.push("Bundle-Buchungen im Onboarding angefordert, aber SubscriptionBundleModule ist nicht im Konsumenten registriert. Bundles wurden nicht angelegt.");
+    }
+    return {
+      plan: planResult.plan,
+      // The adapter returns `string`; the UI expects `'MONTHLY' | 'YEARLY'`.
+      // DTO pre-validation + the server-side PlanCatalog check
+      // guarantee that only valid values reach this point.
+      billingCycle: planResult.billingCycle,
+      bundlesAdded,
+      promoRedemption,
+      warnings
+    };
+  }
+  // ---------------------------------------------------------------------
+  // Accept pending plan version — TENANT_ADMIN
+  // ---------------------------------------------------------------------
+  async acceptPendingPlanVersion(req) {
+    const tenantId = this.requireTenantId(req);
+    const userId = this.requireUserId(req);
+    const sub = await this.subscriptionUsage.findForTenant(tenantId);
+    if (!sub) throw new NotFoundException3(`Keine Subscription f\xFCr Tenant ${tenantId}`);
+    if (!sub.pendingPlanVersion) {
+      throw new BadRequestException("Es liegt aktuell keine Pending-Plan-Version zur Best\xE4tigung vor.");
+    }
+    const result = await this.subscriptionWrite.acceptPendingPlanVersion(tenantId, userId, /* @__PURE__ */ new Date());
+    if (!result.alreadyAccepted) {
+      this.entitlements.invalidateTenant(tenantId);
+      await this.auditLog(req, userId, "Subscription", tenantId, "ACCEPT_PENDING_PLAN_VERSION", {
+        pendingPlanVersionId: sub.pendingPlanVersion.id,
+        pendingPlanId: sub.pendingPlanVersion.planId,
+        pendingPlanVersion: sub.pendingPlanVersion.version,
+        effectiveAt: result.effectiveAt?.toISOString() ?? null
+      });
+    }
+    return {
+      accepted: true,
+      acceptedAt: result.acceptedAt,
+      effectiveAt: result.effectiveAt,
+      idempotent: result.alreadyAccepted
+    };
+  }
+  // ---------------------------------------------------------------------
+  // Cancel — TENANT_ADMIN
+  // ---------------------------------------------------------------------
+  async cancelSubscription(req, dto) {
+    const tenantId = this.requireTenantId(req);
+    const userId = this.requireUserId(req);
+    const result = await this.subscriptionWrite.cancelSubscription(tenantId, !!dto.immediately, /* @__PURE__ */ new Date());
+    this.entitlements.invalidateTenant(tenantId);
+    await this.auditLog(req, userId, "Subscription", tenantId, "CANCEL_SUBSCRIPTION", {
+      immediate: !!dto.immediately,
+      canceledAt: result.canceledAt?.toISOString() ?? null,
+      status: result.status
+    });
+    return {
+      canceledAt: result.canceledAt,
+      status: result.status,
+      immediate: !!dto.immediately
+    };
+  }
+  // ---------------------------------------------------------------------
+  // Helpers
+  // ---------------------------------------------------------------------
+  requireTenantId(req) {
+    const resolver = this.tenantIdResolver ?? ((r) => r.user?.tenantId ?? null);
+    const tenantId = resolver(req);
+    if (!tenantId) {
+      throw new NotFoundException3("Tenant-ID nicht im Request gefunden");
+    }
+    return tenantId;
+  }
+  requireUserId(req) {
+    const resolver = this.userIdResolver ?? ((r) => r.user?.sub ?? r.user?.id ?? null);
+    const userId = resolver(req);
+    if (!userId) {
+      throw new NotFoundException3("User-ID nicht im Request gefunden");
+    }
+    return userId;
+  }
+  buildActor(req, userId) {
+    const email = this.resolveUserEmail(req) ?? "unknown";
+    const contextResolver = this.auditContextResolver ?? ((r) => {
+      const headers = r.headers;
+      const sid = headers?.["x-session-id"];
+      if (Array.isArray(sid)) return sid[0] ?? null;
+      return sid ?? null;
+    });
+    const context = contextResolver(req) ?? "tenant-self-service";
+    return {
+      userId,
+      email,
+      source: "web",
+      context
+    };
+  }
+  resolveUserEmail(req) {
+    const emailResolver = this.userEmailResolver ?? ((r) => r.user?.email ?? null);
+    return emailResolver(req) ?? null;
+  }
+  toResponseRedemption(redemption, code) {
+    return {
+      code: code.toUpperCase(),
+      discount: {
+        valueType: redemption.appliedValueType,
+        value: String(redemption.appliedValue),
+        durationType: redemption.appliedDurationType,
+        durationValue: redemption.appliedDurationValue
+      },
+      startsAt: redemption.startsAt.toISOString(),
+      endsAt: redemption.endsAt ? redemption.endsAt.toISOString() : null
+    };
+  }
+  collectPromoSkipReasons(promoCode, sub) {
+    const reasons = [];
+    if (!this.promoCodes) {
+      reasons.push(`Promo-Code "${promoCode}" wurde gesendet, aber PromoCodesModule ist nicht geladen \u2014 der Code wurde NICHT eingel\xF6st.`);
+    }
+    if (!sub.id) {
+      reasons.push(`Promo-Code "${promoCode}" wurde gesendet, aber der Adapter liefert keine SubscriptionUsageRecord.id \u2014 der Code wurde NICHT eingel\xF6st.`);
+    }
+    return reasons;
+  }
+  /**
+   * #18: contract freeze after the plan change — non-fatal, only outside of
+   * the trial (during a trial the trial entitlements apply, not the booked plan;
+   * the freeze happens on the transition to ACTIVE, i.e. on materialization).
+   * Without a configured `contractFreeze` hook the call is a no-op.
+   */
+  async tryFreezeOnPlanChange(tenantId, plan, cycle, wasTrial) {
+    if (wasTrial || !this.contractFreeze) return;
+    try {
+      await this.contractFreeze.freezeOnPlanChange(tenantId, plan, cycle, /* @__PURE__ */ new Date());
+    } catch (err) {
+      this.logger.error(`Contract-Freeze nach Plan-Wechsel fehlgeschlagen (tenant ${tenantId}): ${String(err)}`);
+    }
+  }
+  /**
+   * Audit-log helper — writes best-effort, does not block the response path.
+   * If `AdminAuditService` is not injected (e.g. a minimal deploy without
+   * AdminModule), the call is silently discarded.
+   */
+  async auditLog(req, userId, entity, entityId, action, changes) {
+    if (!this.auditService) return;
+    try {
+      await this.auditService.log({
+        actor: this.buildActor(req, userId),
+        entity,
+        entityId,
+        action,
+        changes
+      });
+    } catch {
+    }
+  }
+};
+_ts_decorate17([
+  Get2("entitlement"),
+  _ts_param11(0, Req()),
+  _ts_metadata13("design:type", Function),
+  _ts_metadata13("design:paramtypes", [
+    typeof RequestLike === "undefined" ? Object : RequestLike
+  ]),
+  _ts_metadata13("design:returntype", Promise)
+], TenantBillingController.prototype, "getEntitlement", null);
+_ts_decorate17([
+  Get2("usage"),
+  _ts_param11(0, Req()),
+  _ts_metadata13("design:type", Function),
+  _ts_metadata13("design:paramtypes", [
+    typeof RequestLike === "undefined" ? Object : RequestLike
+  ]),
+  _ts_metadata13("design:returntype", Promise)
+], TenantBillingController.prototype, "getUsage", null);
+_ts_decorate17([
+  Post2("plan/preview"),
+  HttpCode(HttpStatus2.OK),
+  UseGuards2(TenantAdminGuard),
+  _ts_param11(0, Req()),
+  _ts_param11(1, Body2()),
+  _ts_metadata13("design:type", Function),
+  _ts_metadata13("design:paramtypes", [
+    typeof RequestLike === "undefined" ? Object : RequestLike,
+    typeof PreviewPlanChangeDto === "undefined" ? Object : PreviewPlanChangeDto
+  ]),
+  _ts_metadata13("design:returntype", Promise)
+], TenantBillingController.prototype, "previewPlanChange", null);
+_ts_decorate17([
+  Post2("plan"),
+  UseGuards2(TenantAdminGuard),
+  _ts_param11(0, Req()),
+  _ts_param11(1, Body2()),
+  _ts_metadata13("design:type", Function),
+  _ts_metadata13("design:paramtypes", [
+    typeof RequestLike === "undefined" ? Object : RequestLike,
+    typeof ChangePlanDto === "undefined" ? Object : ChangePlanDto
+  ]),
+  _ts_metadata13("design:returntype", Promise)
+], TenantBillingController.prototype, "changePlan", null);
+_ts_decorate17([
+  Post2("onboarding/initial-subscription"),
+  UseGuards2(TenantAdminGuard),
+  _ts_param11(0, Req()),
+  _ts_param11(1, Body2()),
+  _ts_metadata13("design:type", Function),
+  _ts_metadata13("design:paramtypes", [
+    typeof RequestLike === "undefined" ? Object : RequestLike,
+    typeof CompleteOnboardingSubscriptionDto === "undefined" ? Object : CompleteOnboardingSubscriptionDto
+  ]),
+  _ts_metadata13("design:returntype", Promise)
+], TenantBillingController.prototype, "completeOnboardingSubscription", null);
+_ts_decorate17([
+  Post2("subscription/accept-pending-version"),
+  UseGuards2(TenantAdminGuard),
+  _ts_param11(0, Req()),
+  _ts_metadata13("design:type", Function),
+  _ts_metadata13("design:paramtypes", [
+    typeof RequestLike === "undefined" ? Object : RequestLike
+  ]),
+  _ts_metadata13("design:returntype", Promise)
+], TenantBillingController.prototype, "acceptPendingPlanVersion", null);
+_ts_decorate17([
+  Post2("cancel"),
+  UseGuards2(TenantAdminGuard),
+  _ts_param11(0, Req()),
+  _ts_param11(1, Body2()),
+  _ts_metadata13("design:type", Function),
+  _ts_metadata13("design:paramtypes", [
+    typeof RequestLike === "undefined" ? Object : RequestLike,
+    typeof CancelSubscriptionDto === "undefined" ? Object : CancelSubscriptionDto
+  ]),
+  _ts_metadata13("design:returntype", Promise)
+], TenantBillingController.prototype, "cancelSubscription", null);
+TenantBillingController = _ts_decorate17([
+  Controller3("billing"),
+  UseGuards2(ComposedTenantAuthGuard),
+  _ts_param11(0, Inject11(EntitlementService)),
+  _ts_param11(1, Inject11(PlanChangePreviewService)),
+  _ts_param11(2, Inject11(SUBSCRIPTION_USAGE_PORT_TOKEN)),
+  _ts_param11(3, Inject11(USAGE_SNAPSHOT_PORT_TOKEN)),
+  _ts_param11(4, Inject11(SUBSCRIPTION_WRITE_PORT_TOKEN)),
+  _ts_param11(5, Optional8()),
+  _ts_param11(5, Inject11(TENANT_ID_RESOLVER_TOKEN)),
+  _ts_param11(6, Optional8()),
+  _ts_param11(6, Inject11(USER_ID_RESOLVER_TOKEN)),
+  _ts_param11(7, Optional8()),
+  _ts_param11(7, Inject11(SELF_SERVICE_BLOCKED_PLANS_TOKEN)),
+  _ts_param11(8, Optional8()),
+  _ts_param11(8, Inject11(PromoCodesService)),
+  _ts_param11(9, Optional8()),
+  _ts_param11(9, Inject11(AdminAuditService)),
+  _ts_param11(10, Optional8()),
+  _ts_param11(10, Inject11(USER_EMAIL_RESOLVER_TOKEN)),
+  _ts_param11(11, Optional8()),
+  _ts_param11(11, Inject11(AUDIT_CONTEXT_RESOLVER_TOKEN)),
+  _ts_param11(12, Optional8()),
+  _ts_param11(12, Inject11(SubscriptionBundlesService)),
+  _ts_param11(13, Optional8()),
+  _ts_param11(13, Inject11(CONTRACT_FREEZE_PORT_TOKEN)),
+  _ts_param11(14, Optional8()),
+  _ts_param11(14, Inject11(TRIAL_PROJECTION_PORT_TOKEN)),
+  _ts_metadata13("design:type", Function),
+  _ts_metadata13("design:paramtypes", [
+    typeof EntitlementService === "undefined" ? Object : EntitlementService,
+    typeof PlanChangePreviewService === "undefined" ? Object : PlanChangePreviewService,
+    typeof SubscriptionUsagePort === "undefined" ? Object : SubscriptionUsagePort,
+    typeof UsageSnapshotPort === "undefined" ? Object : UsageSnapshotPort,
+    typeof TenantSubscriptionWritePort === "undefined" ? Object : TenantSubscriptionWritePort,
+    Object,
+    Object,
+    Object,
+    Object,
+    Object,
+    Object,
+    Object,
+    Object,
+    Object,
+    Object
+  ])
+], TenantBillingController);
+
+// src/billing/tenant-billing.module.ts
+import { Module as Module3 } from "@nestjs/common";
+function _ts_decorate18(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate18, "_ts_decorate");
+var TenantBillingModule = class _TenantBillingModule {
+  static {
+    __name(this, "TenantBillingModule");
+  }
+  static forRoot(options) {
+    const providers = [
+      asProvider(TENANT_AUTH_GUARDS_TOKEN, options.authGuards),
+      asProvider(SUBSCRIPTION_USAGE_PORT_TOKEN, options.subscriptionUsagePort),
+      asProvider(USAGE_SNAPSHOT_PORT_TOKEN, options.usageSnapshotPort),
+      asProvider(SUBSCRIPTION_WRITE_PORT_TOKEN, options.subscriptionWritePort),
+      ComposedTenantAuthGuard,
+      TenantAdminGuard,
+      PlanChangePreviewService
+    ];
+    if (options.selfServiceBlockedPlans) {
+      providers.push({
+        provide: SELF_SERVICE_BLOCKED_PLANS_TOKEN,
+        useValue: options.selfServiceBlockedPlans
+      });
+    }
+    if (options.trialProjectionPort) {
+      providers.push(asProvider(TRIAL_PROJECTION_PORT_TOKEN, options.trialProjectionPort));
+    }
+    const hasPendingPlanQueryPort = Boolean(options.pendingPlanQueryPort);
+    if (options.pendingPlanQueryPort) {
+      providers.push(asProvider(PENDING_PLAN_QUERY_PORT_TOKEN, options.pendingPlanQueryPort), PendingPlanMaterializationService);
+    }
+    const hasContractFreeze = Boolean(options.contractFreeze);
+    if (options.contractFreeze) {
+      providers.push({
+        provide: CONTRACT_FREEZE_PROJECT_KEY_TOKEN,
+        useValue: options.contractFreeze.projectKey
+      }, asProvider(CONTRACT_FREEZE_SOURCE_PORT_TOKEN, options.contractFreeze.sourcePort), asProvider(SUBSCRIPTION_CONTRACT_REPOSITORY_TOKEN, options.contractFreeze.subscriptionContractRepository), SubscriptionContractService, {
+        provide: CONTRACT_FREEZE_PORT_TOKEN,
+        useClass: SubscriptionContractFreezeService
+      });
+    }
+    if (options.tenantIdResolver) {
+      providers.push({
+        provide: TENANT_ID_RESOLVER_TOKEN,
+        useValue: options.tenantIdResolver
+      });
+    }
+    if (options.userIdResolver) {
+      providers.push({
+        provide: USER_ID_RESOLVER_TOKEN,
+        useValue: options.userIdResolver
+      });
+    }
+    if (options.userEmailResolver) {
+      providers.push({
+        provide: USER_EMAIL_RESOLVER_TOKEN,
+        useValue: options.userEmailResolver
+      });
+    }
+    if (options.auditContextResolver) {
+      providers.push({
+        provide: AUDIT_CONTEXT_RESOLVER_TOKEN,
+        useValue: options.auditContextResolver
+      });
+    }
+    if (options.extraProviders) providers.push(...options.extraProviders);
+    return {
+      module: _TenantBillingModule,
+      global: options.global ?? false,
+      imports: options.imports ?? [],
+      controllers: [
+        TenantBillingController
+      ],
+      providers,
+      exports: [
+        ComposedTenantAuthGuard,
+        TenantAdminGuard,
+        PlanChangePreviewService,
+        SUBSCRIPTION_USAGE_PORT_TOKEN,
+        USAGE_SNAPSHOT_PORT_TOKEN,
+        SUBSCRIPTION_WRITE_PORT_TOKEN,
+        ...hasPendingPlanQueryPort ? [
+          PendingPlanMaterializationService
+        ] : [],
+        ...hasContractFreeze ? [
+          CONTRACT_FREEZE_PORT_TOKEN
+        ] : []
+      ]
+    };
+  }
+};
+TenantBillingModule = _ts_decorate18([
+  Module3({})
+], TenantBillingModule);
+
+// src/billing/configurator-catalog-builder.ts
+import { Injectable as Injectable10 } from "@nestjs/common";
+function _ts_decorate19(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate19, "_ts_decorate");
+var ConfiguratorCatalogBuilder = class {
+  static {
+    __name(this, "ConfiguratorCatalogBuilder");
+  }
+  async build(input) {
+    const { sources, marketing } = input;
+    const planRows = await sources.listLivePlans();
+    const planMarketingByPlanId = new Map(marketing.listPlanMarketing().map((m) => [
+      m.planId,
+      m
+    ]));
+    return {
+      cycleDiscount: marketing.getCycleDiscount(),
+      currency: marketing.getCurrency(),
+      vatRate: marketing.getVatRate(),
+      models: planRows.filter((row) => row.marketed).map((row) => buildModel(row, planMarketingByPlanId)).filter((m) => m !== null)
+    };
+  }
+};
+ConfiguratorCatalogBuilder = _ts_decorate19([
+  Injectable10()
+], ConfiguratorCatalogBuilder);
+function buildModel(row, marketing) {
+  const m = marketing.get(row.planId);
+  if (!m) return null;
+  return {
+    id: row.planId.toLowerCase(),
+    code: m.code,
+    name: m.name,
+    glyph: m.glyph,
+    tagline: m.tagline,
+    planId: row.planId,
+    monthlyNet: row.monthlyNet,
+    yearlyNet: row.yearlyNet,
+    tags: m.tags,
+    includedFeatureKeys: row.features,
+    quotaBase: normalizeQuotas(row.quotas),
+    ...m.popular ? {
+      popular: true
+    } : {}
+  };
+}
+__name(buildModel, "buildModel");
+function normalizeQuotas(quotas) {
+  const out = {};
+  for (const [k, v] of Object.entries(quotas)) {
+    out[k] = v === -1 ? Number.MAX_SAFE_INTEGER : v;
+  }
+  return out;
+}
+__name(normalizeQuotas, "normalizeQuotas");
+
+// src/billing/subscription-bundle-preview.service.ts
+import { Inject as Inject12, Injectable as Injectable11, NotFoundException as NotFoundException4, Optional as Optional9 } from "@nestjs/common";
+import { buildFeatureRequiresIndex as buildFeatureRequiresIndex3, collectUnsatisfiedRequires as collectUnsatisfiedRequires3 } from "@saasicat/types";
+function _ts_decorate20(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate20, "_ts_decorate");
+function _ts_metadata14(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata14, "_ts_metadata");
+function _ts_param12(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param12, "_ts_param");
+var SubscriptionBundlePreviewService = class {
+  static {
+    __name(this, "SubscriptionBundlePreviewService");
+  }
+  subscriptionBundles;
+  bundles;
+  plans;
+  catalogEntries;
+  blockedBundles;
+  defaultMinTermMonths;
+  constructor(subscriptionBundles, bundles, plans = null, catalogEntries = null, blockedBundles = null, config = {}) {
+    this.subscriptionBundles = subscriptionBundles;
+    this.bundles = bundles;
+    this.plans = plans;
+    this.catalogEntries = catalogEntries;
+    this.blockedBundles = blockedBundles;
+    this.defaultMinTermMonths = config.defaultMinimumTermMonths ?? 12;
+  }
+  async previewAdd(ctx, input, now = /* @__PURE__ */ new Date()) {
+    const bundleVersion = await this.bundles.findVersionById(input.bundleVersionId);
+    if (!bundleVersion) {
+      throw new NotFoundException4(`BundleVersion '${input.bundleVersionId}' nicht gefunden`);
+    }
+    const blockers = [];
+    const warnings = [];
+    this.collectBookabilityBlockers(bundleVersion, ctx.currentPlanKey, blockers);
+    const activeBundleVersions = await this.loadActiveBundleVersions(ctx.subscriptionId);
+    if (activeBundleVersions.some((bv) => bv.id === bundleVersion.id)) {
+      blockers.push({
+        code: "BUNDLE_ALREADY_SUBSCRIBED",
+        message: "Dieses Bundle ist bereits aktiv gebucht."
+      });
+    }
+    const planFeatures = new Set(await this.resolvePlanFeatures(ctx.currentPlanKey, now));
+    const redundantFeatures = this.collectRedundantFeatures(bundleVersion, planFeatures, ctx.currentPlanKey, activeBundleVersions);
+    if (redundantFeatures.length > 0) {
+      warnings.push({
+        code: "REDUNDANT_FEATURES",
+        message: `${redundantFeatures.length} Feature${redundantFeatures.length === 1 ? " ist" : "s sind"} bereits im Plan oder einem anderen gebuchten Bundle enthalten \u2014 das Bundle w\xFCrde daf\xFCr doppelt bezahlt.`
+      });
+    }
+    const missingRequires = await this.collectMissingRequires(bundleVersion, planFeatures, activeBundleVersions);
+    if (missingRequires.length > 0) {
+      blockers.push({
+        code: "BUNDLE_FEATURE_DEPENDENCY_UNSATISFIED",
+        message: `Das Bundle ben\xF6tigt [${missingRequires.join(", ")}] \u2014 weder im Plan noch in den aktiven Bundles enthalten.`
+      });
+    }
+    const priceNet = resolveBundlePriceNet(bundleVersion, ctx.currentPlanKey, ctx.billingCycle);
+    const proration = ctx.status !== "TRIAL" && priceNet !== null ? computeProration({
+      periodStart: ctx.currentPeriodStart ?? ctx.startedAt ?? now,
+      periodEnd: ctx.currentPeriodEnd ?? periodEndAfter(ctx.startedAt, ctx.billingCycle, now),
+      now,
+      currentPriceNet: 0,
+      targetPriceNet: priceNet
+    }) : null;
+    const minimumTermMonths = input.minimumTermMonths ?? this.defaultMinTermMonths;
+    return {
+      action: "add",
+      bundle: toSnapshot(bundleVersion),
+      billingCycle: ctx.billingCycle,
+      proration,
+      nextPeriodPriceNet: priceNet,
+      minimumTermMonths,
+      minimumTermEndsAt: minimumTermMonths > 0 ? addMonths(now, minimumTermMonths) : null,
+      redundantFeatures,
+      missingRequires,
+      blockers,
+      warnings
+    };
+  }
+  async previewCancel(ctx, input, now = /* @__PURE__ */ new Date()) {
+    const existing = await this.subscriptionBundles.findById(input.subscriptionBundleId);
+    if (!existing || existing.subscriptionId !== ctx.subscriptionId) {
+      throw new NotFoundException4(`SubscriptionBundle '${input.subscriptionBundleId}' nicht gefunden`);
+    }
+    const bundleVersion = await this.bundles.findVersionById(existing.bundleVersionId);
+    if (!bundleVersion) {
+      throw new NotFoundException4(`BundleVersion '${existing.bundleVersionId}' nicht gefunden`);
+    }
+    const blockers = [];
+    const warnings = [];
+    if (existing.canceledAt !== null) {
+      blockers.push({
+        code: "SUBSCRIPTION_BUNDLE_ALREADY_CANCELED",
+        message: "Diese Bundle-Buchung ist bereits gek\xFCndigt."
+      });
+    }
+    const effectiveAt = resolveBundleCancelEffectiveAt({
+      canceledAt: now,
+      currentPeriodEnd: ctx.currentPeriodEnd,
+      minimumTermEndsAt: existing.minimumTermEndsAt
+    });
+    const periodEnd = ctx.currentPeriodEnd ?? now;
+    if (existing.minimumTermEndsAt && existing.minimumTermEndsAt.getTime() > periodEnd.getTime()) {
+      warnings.push({
+        code: "MINIMUM_TERM_BINDS",
+        message: "Die Mindestlaufzeit bindet \xFCber das Periodenende hinaus \u2014 die K\xFCndigung wirkt erst zum Mindestlaufzeit-Ende."
+      });
+    }
+    return {
+      action: "cancel",
+      subscriptionBundleId: existing.id,
+      bundle: toSnapshot(bundleVersion),
+      billingCycle: ctx.billingCycle,
+      effectiveAt,
+      nextPeriodSavingsNet: resolveBundlePriceNet(bundleVersion, ctx.currentPlanKey, ctx.billingCycle),
+      blockers,
+      warnings
+    };
+  }
+  /** Bookability checks — same codes as `addBundleToSubscription` (422 path). */
+  collectBookabilityBlockers(bundleVersion, currentPlanKey, blockers) {
+    if (bundleVersion.publishedAt === null) {
+      blockers.push({
+        code: "BUNDLE_VERSION_NOT_PUBLISHED",
+        message: "Diese BundleVersion ist nicht ver\xF6ffentlicht und nicht buchbar."
+      });
+    }
+    if (bundleVersion.supersededAt !== null) {
+      blockers.push({
+        code: "BUNDLE_VERSION_SUPERSEDED",
+        message: "Diese BundleVersion wurde durch eine Nachfolge-Version abgel\xF6st."
+      });
+    }
+    const planIds = bundleVersion.compatibility?.planIds ?? [];
+    if (planIds.length > 0 && !planIds.includes(currentPlanKey)) {
+      blockers.push({
+        code: "BUNDLE_INCOMPATIBLE_WITH_PLAN",
+        message: `Das Bundle ist nicht mit Plan '${currentPlanKey}' kompatibel. Erlaubt: [${planIds.join(", ")}].`
+      });
+    }
+    if (this.blockedBundles?.bundleKeys?.includes(bundleVersion.bundleKey)) {
+      blockers.push({
+        code: "BUNDLE_NOT_SELF_SERVICE",
+        message: `Bundle '${bundleVersion.bundleKey}' wird nur per Sondervertrag aktiviert. Bitte den Vertragsbetreuer kontaktieren.`
+      });
+    }
+  }
+  /** Versions of the active bundle bookings (for redundancy + requires coverage). */
+  async loadActiveBundleVersions(subscriptionId) {
+    const active = await this.subscriptionBundles.listActiveBySubscription(subscriptionId);
+    const versions = await Promise.all(active.map((booking) => this.bundles.findVersionById(booking.bundleVersionId)));
+    return versions.filter((bv) => bv !== null);
+  }
+  /** Features of the currently live PlanVersion state; empty without PlanRepository. */
+  async resolvePlanFeatures(planKey, asOf) {
+    if (!this.plans) return [];
+    const live = await this.plans.findActivePlanVersion?.(planKey, asOf) ?? await this.plans.findLatestLivePlanVersion?.(planKey);
+    return live?.features ?? [];
+  }
+  collectRedundantFeatures(bundleVersion, planFeatures, currentPlanKey, activeBundleVersions) {
+    const hints = [];
+    for (const featureKey of bundleVersion.features ?? []) {
+      if (planFeatures.has(featureKey)) {
+        hints.push({
+          featureKey,
+          coveredBy: "PLAN",
+          coveredByKey: currentPlanKey
+        });
+        continue;
+      }
+      const coveringBundle = activeBundleVersions.find((bv) => (bv.features ?? []).includes(featureKey));
+      if (coveringBundle) {
+        hints.push({
+          featureKey,
+          coveredBy: "BUNDLE",
+          coveredByKey: coveringBundle.bundleKey
+        });
+      }
+    }
+    return hints;
+  }
+  /**
+   * requires of the new bundle that neither the bundle itself nor plan ∪
+   * active bundles cover (#35). Empty without CatalogEntryRepository.
+   */
+  async collectMissingRequires(bundleVersion, planFeatures, activeBundleVersions) {
+    if (!this.catalogEntries) return [];
+    const projectKey = await this.resolveProjectKey(bundleVersion);
+    if (!projectKey) return [];
+    const entries = await this.catalogEntries.listFeatures({
+      projectKey
+    });
+    const requiresIndex = buildFeatureRequiresIndex3(entries);
+    const covered = /* @__PURE__ */ new Set([
+      ...planFeatures,
+      ...activeBundleVersions.flatMap((bv) => bv.features ?? [])
+    ]);
+    return collectUnsatisfiedRequires3(bundleVersion.features ?? [], requiresIndex).filter((key) => !covered.has(key));
+  }
+  /** `projectKey` lives on the bundle stem, not on the version. */
+  async resolveProjectKey(bundleVersion) {
+    const stem = await this.bundles.findById(bundleVersion.bundleId);
+    return stem?.projectKey ?? null;
+  }
+};
+SubscriptionBundlePreviewService = _ts_decorate20([
+  Injectable11(),
+  _ts_param12(0, Inject12(SUBSCRIPTION_BUNDLE_REPOSITORY_TOKEN)),
+  _ts_param12(1, Inject12(BUNDLE_REPOSITORY_TOKEN)),
+  _ts_param12(2, Optional9()),
+  _ts_param12(2, Inject12(PLAN_REPOSITORY_TOKEN)),
+  _ts_param12(3, Optional9()),
+  _ts_param12(3, Inject12(CATALOG_ENTRY_REPOSITORY_TOKEN)),
+  _ts_param12(4, Optional9()),
+  _ts_param12(4, Inject12(SELF_SERVICE_BLOCKED_BUNDLES_TOKEN)),
+  _ts_param12(5, Optional9()),
+  _ts_param12(5, Inject12(SUBSCRIPTION_BUNDLE_CONFIG_TOKEN)),
+  _ts_metadata14("design:type", Function),
+  _ts_metadata14("design:paramtypes", [
+    typeof SubscriptionBundleRepository === "undefined" ? Object : SubscriptionBundleRepository,
+    typeof BundleRepository === "undefined" ? Object : BundleRepository,
+    Object,
+    Object,
+    Object,
+    typeof SubscriptionBundleConfig === "undefined" ? Object : SubscriptionBundleConfig
+  ])
+], SubscriptionBundlePreviewService);
+function resolveBundlePriceNet(bundleVersion, planKey, billingCycle) {
+  const override = (bundleVersion.pricingOverrides ?? []).find((o) => o.planId === planKey && !o.businessTypeKey);
+  const yearly = billingCycle === "YEARLY";
+  const raw = yearly ? override?.yearlyNet !== void 0 ? override.yearlyNet : bundleVersion.yearlyNet : override?.monthlyNet !== void 0 ? override.monthlyNet : bundleVersion.monthlyNet;
+  if (raw === null || raw === void 0) return null;
+  const parsed = Number.parseFloat(raw);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+__name(resolveBundlePriceNet, "resolveBundlePriceNet");
+function toSnapshot(bundleVersion) {
+  return {
+    bundleKey: bundleVersion.bundleKey,
+    label: bundleVersion.label,
+    bundleVersionId: bundleVersion.id,
+    features: [
+      ...bundleVersion.features ?? []
+    ],
+    quotas: {
+      ...bundleVersion.quotas ?? {}
+    }
+  };
+}
+__name(toSnapshot, "toSnapshot");
+
+// src/billing/subscription-bundles.module.ts
+import { Module as Module4 } from "@nestjs/common";
+
+// src/billing/tenant-subscription-bundles.controller.ts
+import { BadRequestException as BadRequestException2, Body as Body3, Controller as Controller4, Delete, Get as Get3, HttpCode as HttpCode2, HttpStatus as HttpStatus3, Inject as Inject13, Logger as Logger5, NotFoundException as NotFoundException5, Optional as Optional10, Param, ParseUUIDPipe, Post as Post3, Req as Req2, UseGuards as UseGuards3 } from "@nestjs/common";
+
+// src/billing/dto/subscription-bundles.dto.ts
+import { IsInt, IsOptional as IsOptional4, IsUUID as IsUUID2, Matches as Matches3, Max, Min } from "class-validator";
+function _ts_decorate21(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate21, "_ts_decorate");
+function _ts_metadata15(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata15, "_ts_metadata");
+var ISO_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}(T.*)?$/;
+var AddSubscriptionBundleDto = class {
+  static {
+    __name(this, "AddSubscriptionBundleDto");
+  }
+  bundleVersionId;
+  /**
+   * Optional — override for the minimum term (months). `0` = no
+   * minimum term. Default comes from the `SubscriptionBundleConfig`
+   * (platform = 12 months).
+   */
+  minimumTermMonths;
+};
+_ts_decorate21([
+  IsUUID2(),
+  _ts_metadata15("design:type", String)
+], AddSubscriptionBundleDto.prototype, "bundleVersionId", void 0);
+_ts_decorate21([
+  IsOptional4(),
+  IsInt(),
+  Min(0),
+  Max(120),
+  _ts_metadata15("design:type", Number)
+], AddSubscriptionBundleDto.prototype, "minimumTermMonths", void 0);
+var PreviewSubscriptionBundleDto = class {
+  static {
+    __name(this, "PreviewSubscriptionBundleDto");
+  }
+  /** Add preview: BundleVersion to be booked. */
+  bundleVersionId;
+  /** Cancel preview: existing Bundle booking. */
+  subscriptionBundleId;
+  /** Add preview only — override analogous to `AddSubscriptionBundleDto`. */
+  minimumTermMonths;
+};
+_ts_decorate21([
+  IsOptional4(),
+  IsUUID2(),
+  _ts_metadata15("design:type", String)
+], PreviewSubscriptionBundleDto.prototype, "bundleVersionId", void 0);
+_ts_decorate21([
+  IsOptional4(),
+  IsUUID2(),
+  _ts_metadata15("design:type", String)
+], PreviewSubscriptionBundleDto.prototype, "subscriptionBundleId", void 0);
+_ts_decorate21([
+  IsOptional4(),
+  IsInt(),
+  Min(0),
+  Max(120),
+  _ts_metadata15("design:type", Number)
+], PreviewSubscriptionBundleDto.prototype, "minimumTermMonths", void 0);
+var CancelSubscriptionBundleDto = class {
+  static {
+    __name(this, "CancelSubscriptionBundleDto");
+  }
+  /**
+   * Optional — default = `new Date()` server-side. Format: ISO-8601
+   * (`YYYY-MM-DD` or full timestamp). Usually not set by the tenant
+   * self-service.
+   */
+  canceledAt;
+};
+_ts_decorate21([
+  IsOptional4(),
+  Matches3(ISO_DATE_PATTERN, {
+    message: "canceledAt muss ISO-Datum sein (YYYY-MM-DD)"
+  }),
+  _ts_metadata15("design:type", String)
+], CancelSubscriptionBundleDto.prototype, "canceledAt", void 0);
+
+// src/billing/tenant-subscription-bundles.controller.ts
+function _ts_decorate22(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate22, "_ts_decorate");
+function _ts_metadata16(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata16, "_ts_metadata");
+function _ts_param13(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param13, "_ts_param");
+function buildTenantSubscriptionBundlesController(extraGuards = []) {
+  let GeneratedTenantSubscriptionBundlesController = class GeneratedTenantSubscriptionBundlesController {
+    static {
+      __name(this, "GeneratedTenantSubscriptionBundlesController");
+    }
+    service;
+    previewService;
+    subscriptionUsage;
+    tenantIdResolver;
+    contractFreeze;
+    logger = new Logger5("TenantSubscriptionBundlesController");
+    constructor(service, previewService, subscriptionUsage, tenantIdResolver, contractFreeze = null) {
+      this.service = service;
+      this.previewService = previewService;
+      this.subscriptionUsage = subscriptionUsage;
+      this.tenantIdResolver = tenantIdResolver;
+      this.contractFreeze = contractFreeze;
+    }
+    async list(req) {
+      const sub = await this.requireSubscription(this.requireTenantId(req));
+      return this.service.listForSubscription(this.requireSubscriptionPk(sub));
+    }
+    async add(req, dto) {
+      const tenantId = this.requireTenantId(req);
+      const sub = await this.requireSubscription(tenantId);
+      const result = await this.service.addBundleToSubscription({
+        subscriptionId: this.requireSubscriptionPk(sub),
+        bundleVersionId: dto.bundleVersionId,
+        // Plan KEY (compatibility.planIds is key-based) — not the planVersion UUID.
+        currentPlanKey: sub.plan,
+        minimumTermMonths: dto.minimumTermMonths
+      });
+      await this.refreezeContract(tenantId, sub);
+      return result;
+    }
+    async preview(req, dto) {
+      const hasAdd = Boolean(dto.bundleVersionId);
+      const hasCancel = Boolean(dto.subscriptionBundleId);
+      if (hasAdd === hasCancel) {
+        throw new BadRequestException2("Genau eines von bundleVersionId (Add-Preview) oder subscriptionBundleId (Cancel-Preview) angeben.");
+      }
+      const sub = await this.requireSubscription(this.requireTenantId(req));
+      const ctx = {
+        subscriptionId: this.requireSubscriptionPk(sub),
+        // Plan KEY (compatibility.planIds is key-based) — not the planVersion UUID.
+        currentPlanKey: sub.plan,
+        billingCycle: sub.billingCycle,
+        status: sub.status,
+        startedAt: sub.startedAt,
+        currentPeriodStart: sub.currentPeriodStart,
+        currentPeriodEnd: sub.currentPeriodEnd
+      };
+      return hasAdd ? this.previewService.previewAdd(ctx, {
+        bundleVersionId: dto.bundleVersionId,
+        minimumTermMonths: dto.minimumTermMonths
+      }) : this.previewService.previewCancel(ctx, {
+        subscriptionBundleId: dto.subscriptionBundleId
+      });
+    }
+    async cancel(req, subscriptionBundleId, dto = {}) {
+      const tenantId = this.requireTenantId(req);
+      const sub = await this.requireSubscription(tenantId);
+      const result = await this.service.cancelBundleFromSubscription({
+        subscriptionBundleId,
+        canceledAt: dto.canceledAt ? new Date(dto.canceledAt) : void 0,
+        currentPeriodEnd: sub.currentPeriodEnd ?? void 0
+      });
+      await this.refreezeContract(tenantId, sub);
+      return result;
+    }
+    async reactivate(req, subscriptionBundleId) {
+      const tenantId = this.requireTenantId(req);
+      const sub = await this.requireSubscription(tenantId);
+      const result = await this.service.reactivateBundle(subscriptionBundleId);
+      await this.refreezeContract(tenantId, sub);
+      return result;
+    }
+    requireSubscriptionPk(sub) {
+      if (!sub.id) {
+        throw new NotFoundException5("SubscriptionUsageRecord ohne `id` \u2014 Adapter muss die Subscription-PK durchreichen (siehe SubscriptionUsageRecord.id).");
+      }
+      return sub.id;
+    }
+    requireTenantId(req) {
+      const tenantId = this.tenantIdResolver(req);
+      if (!tenantId) {
+        throw new NotFoundException5("Tenant-ID nicht im Request gefunden");
+      }
+      return tenantId;
+    }
+    async requireSubscription(tenantId) {
+      const sub = await this.subscriptionUsage.findForTenant(tenantId);
+      if (!sub) {
+        throw new NotFoundException5(`Keine Subscription f\xFCr Tenant ${tenantId}`);
+      }
+      return sub;
+    }
+    /**
+     * Re-freeze with the unchanged plan after bundle add/cancel (#61) —
+     * only if the consumer has wired the ContractFreezePort.
+     */
+    async refreezeContract(tenantId, sub) {
+      if (!this.contractFreeze) return;
+      try {
+        await this.contractFreeze.freezeOnPlanChange(tenantId, sub.planVersion.planId, sub.billingCycle, /* @__PURE__ */ new Date());
+      } catch (err) {
+        this.logger.error(`Contract-Freeze nach Bundle-Mutation fehlgeschlagen (tenant ${tenantId}): ${String(err)}`);
+      }
+    }
+  };
+  _ts_decorate22([
+    Get3(),
+    _ts_param13(0, Req2()),
+    _ts_metadata16("design:type", Function),
+    _ts_metadata16("design:paramtypes", [
+      typeof RequestLike === "undefined" ? Object : RequestLike
+    ]),
+    _ts_metadata16("design:returntype", Promise)
+  ], GeneratedTenantSubscriptionBundlesController.prototype, "list", null);
+  _ts_decorate22([
+    Post3(),
+    _ts_param13(0, Req2()),
+    _ts_param13(1, Body3()),
+    _ts_metadata16("design:type", Function),
+    _ts_metadata16("design:paramtypes", [
+      typeof RequestLike === "undefined" ? Object : RequestLike,
+      typeof AddSubscriptionBundleDto === "undefined" ? Object : AddSubscriptionBundleDto
+    ]),
+    _ts_metadata16("design:returntype", Promise)
+  ], GeneratedTenantSubscriptionBundlesController.prototype, "add", null);
+  _ts_decorate22([
+    Post3("preview"),
+    HttpCode2(HttpStatus3.OK),
+    _ts_param13(0, Req2()),
+    _ts_param13(1, Body3()),
+    _ts_metadata16("design:type", Function),
+    _ts_metadata16("design:paramtypes", [
+      typeof RequestLike === "undefined" ? Object : RequestLike,
+      typeof PreviewSubscriptionBundleDto === "undefined" ? Object : PreviewSubscriptionBundleDto
+    ]),
+    _ts_metadata16("design:returntype", Promise)
+  ], GeneratedTenantSubscriptionBundlesController.prototype, "preview", null);
+  _ts_decorate22([
+    Delete(":id"),
+    HttpCode2(HttpStatus3.OK),
+    _ts_param13(0, Req2()),
+    _ts_param13(1, Param("id", new ParseUUIDPipe())),
+    _ts_param13(2, Body3()),
+    _ts_metadata16("design:type", Function),
+    _ts_metadata16("design:paramtypes", [
+      typeof RequestLike === "undefined" ? Object : RequestLike,
+      String,
+      typeof CancelSubscriptionBundleDto === "undefined" ? Object : CancelSubscriptionBundleDto
+    ]),
+    _ts_metadata16("design:returntype", Promise)
+  ], GeneratedTenantSubscriptionBundlesController.prototype, "cancel", null);
+  _ts_decorate22([
+    Post3(":id/reactivate"),
+    HttpCode2(HttpStatus3.OK),
+    _ts_param13(0, Req2()),
+    _ts_param13(1, Param("id", new ParseUUIDPipe())),
+    _ts_metadata16("design:type", Function),
+    _ts_metadata16("design:paramtypes", [
+      typeof RequestLike === "undefined" ? Object : RequestLike,
+      String
+    ]),
+    _ts_metadata16("design:returntype", Promise)
+  ], GeneratedTenantSubscriptionBundlesController.prototype, "reactivate", null);
+  GeneratedTenantSubscriptionBundlesController = _ts_decorate22([
+    Controller4("billing/subscription-bundles"),
+    UseGuards3(ComposedTenantAuthGuard, ...extraGuards),
+    _ts_param13(0, Inject13(SubscriptionBundlesService)),
+    _ts_param13(1, Inject13(SubscriptionBundlePreviewService)),
+    _ts_param13(2, Inject13(SUBSCRIPTION_USAGE_PORT_TOKEN)),
+    _ts_param13(3, Inject13(TENANT_ID_RESOLVER_TOKEN)),
+    _ts_param13(4, Optional10()),
+    _ts_param13(4, Inject13(CONTRACT_FREEZE_PORT_TOKEN)),
+    _ts_metadata16("design:type", Function),
+    _ts_metadata16("design:paramtypes", [
+      typeof SubscriptionBundlesService === "undefined" ? Object : SubscriptionBundlesService,
+      typeof SubscriptionBundlePreviewService === "undefined" ? Object : SubscriptionBundlePreviewService,
+      typeof SubscriptionUsagePort === "undefined" ? Object : SubscriptionUsagePort,
+      typeof TenantIdResolver === "undefined" ? Object : TenantIdResolver,
+      Object
+    ])
+  ], GeneratedTenantSubscriptionBundlesController);
+  return GeneratedTenantSubscriptionBundlesController;
+}
+__name(buildTenantSubscriptionBundlesController, "buildTenantSubscriptionBundlesController");
+
+// src/billing/subscription-bundles.module.ts
+function _ts_decorate23(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate23, "_ts_decorate");
+var SubscriptionBundleModule = class _SubscriptionBundleModule {
+  static {
+    __name(this, "SubscriptionBundleModule");
+  }
+  static forRoot(options) {
+    const providers = [
+      asProvider(SUBSCRIPTION_BUNDLE_REPOSITORY_TOKEN, options.subscriptionBundleRepository),
+      ...options.bundleRepository ? [
+        asProvider(BUNDLE_REPOSITORY_TOKEN, options.bundleRepository)
+      ] : [],
+      {
+        provide: SUBSCRIPTION_BUNDLE_CONFIG_TOKEN,
+        useValue: {
+          defaultMinimumTermMonths: options.defaultMinimumTermMonths ?? 12
+        }
+      },
+      ...options.selfServiceBlockedBundles ? [
+        {
+          provide: SELF_SERVICE_BLOCKED_BUNDLES_TOKEN,
+          useValue: options.selfServiceBlockedBundles
+        }
+      ] : [],
+      SubscriptionBundlesService,
+      SubscriptionBundlePreviewService,
+      ...options.extraProviders ?? []
+    ];
+    const controllers = [];
+    if (options.controller) {
+      providers.push(ComposedTenantAuthGuard);
+      if (options.controller.authGuards) {
+        providers.push(asProvider(TENANT_AUTH_GUARDS_TOKEN, options.controller.authGuards));
+      }
+      if (options.controller.subscriptionUsagePort) {
+        providers.push(asProvider(SUBSCRIPTION_USAGE_PORT_TOKEN, options.controller.subscriptionUsagePort));
+      }
+      providers.push({
+        provide: TENANT_ID_RESOLVER_TOKEN,
+        useValue: options.controller.tenantIdResolver ?? ((req) => req.user?.tenantId ?? null)
+      });
+      controllers.push(buildTenantSubscriptionBundlesController(options.controller.extraGuards ?? []));
+    }
+    return {
+      module: _SubscriptionBundleModule,
+      global: options.global ?? false,
+      imports: options.imports ?? [],
+      controllers,
+      providers,
+      exports: [
+        SubscriptionBundlesService,
+        SubscriptionBundlePreviewService,
+        SUBSCRIPTION_BUNDLE_REPOSITORY_TOKEN
+      ]
+    };
+  }
+};
+SubscriptionBundleModule = _ts_decorate23([
+  Module4({})
+], SubscriptionBundleModule);
+
+export {
+  periodEndAfter,
+  initialPeriodWindow,
+  periodEndWithMinLead,
+  PublishValidationError,
+  assertChangeNote,
+  assertDraftPublishable,
+  assertBaseVersionFresh,
+  assertOptimisticLockHeld,
+  decideRenewal,
+  clearPendingPlanVersionFields,
+  computeNextPeriod,
+  FEATURE_GUARD_CONFIG_TOKEN,
+  UPSELL_OFFER_RESOLVER_TOKEN,
+  UPSELL_OFFER_CURRENCY_TOKEN,
+  FeatureGuard,
+  PUBLIC_CATALOG_PROJECT_KEY_TOKEN,
+  PUBLIC_CATALOG_BUNDLE_REPOSITORY_TOKEN,
+  PUBLIC_CATALOG_BUSINESS_TYPE_REPOSITORY_TOKEN,
+  PUBLIC_CATALOG_MARKETING_REPOSITORY_TOKEN,
+  CatalogBundleUpsellResolver,
+  LimitExceededFilter,
+  PlanCatalogValidationError,
+  loadPlanCatalogFromFile,
+  loadPlanCatalogFromString,
+  PLAN_CATALOG_IMPORT_SINK_TOKEN,
+  PlanCatalogImporterService,
+  PlanCatalogImportDto,
+  buildPlanCatalogImporterController,
+  PlanCatalogImporterModule,
+  FEATURE_UI_REGISTRY_TOKEN,
+  PublicCatalogController,
+  PublicCatalogModule,
+  ComposedTenantAuthGuard,
+  TenantAdminGuard,
+  SELF_SERVICE_BLOCKED_PLANS_TOKEN,
+  SELF_SERVICE_BLOCKED_BUNDLES_TOKEN,
+  computeProration,
+  PlanChangePreviewService,
+  CONTRACT_FREEZE_PORT_TOKEN,
+  CONTRACT_FREEZE_SOURCE_PORT_TOKEN,
+  CONTRACT_FREEZE_PROJECT_KEY_TOKEN,
+  PendingPlanMaterializationService,
+  SubscriptionContractFreezeService,
+  computeCarriedTrialEndsAt,
+  PreviewPlanChangeDto,
+  ChangePlanDto,
+  CancelSubscriptionDto,
+  CompleteOnboardingSubscriptionDto,
+  SubscriptionBundlesService,
+  resolveBundleCancelEffectiveAt,
+  addMonths,
+  TenantBillingController,
+  TenantBillingModule,
+  ConfiguratorCatalogBuilder,
+  SubscriptionBundlePreviewService,
+  resolveBundlePriceNet,
+  buildTenantSubscriptionBundlesController,
+  SubscriptionBundleModule
+};