@saasicat/adapter-prisma 0.5.0 → 0.7.0

package/dist/index.js

@@ -86,7 +86,7 @@ PrismaAuditAdapter = _ts_decorate2([
   _ts_param(0, Inject(PRISMA_CLIENT_TOKEN)),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
-    typeof PrismaLike === "undefined" ? Object : PrismaLike
+    typeof Pick === "undefined" ? Object : Pick
   ])
 ], PrismaAuditAdapter);
 
@@ -149,7 +149,7 @@ PrismaAuditQueryAdapter = _ts_decorate3([
   _ts_param2(0, Inject2(PRISMA_CLIENT_TOKEN)),
   _ts_metadata2("design:type", Function),
   _ts_metadata2("design:paramtypes", [
-    typeof PrismaLike === "undefined" ? Object : PrismaLike
+    typeof Pick === "undefined" ? Object : Pick
   ])
 ], PrismaAuditQueryAdapter);
 function toActorTagFilter(actorTag) {
@@ -221,7 +221,7 @@ PrismaAuditStatsAdapter = _ts_decorate4([
   _ts_param3(0, Inject3(PRISMA_CLIENT_TOKEN)),
   _ts_metadata3("design:type", Function),
   _ts_metadata3("design:paramtypes", [
-    typeof PrismaLike === "undefined" ? Object : PrismaLike
+    typeof Pick === "undefined" ? Object : Pick
   ])
 ], PrismaAuditStatsAdapter);
 
@@ -291,12 +291,149 @@ PrismaMfaAdapter = _ts_decorate5([
   _ts_param4(0, Inject4(PRISMA_CLIENT_TOKEN)),
   _ts_metadata4("design:type", Function),
   _ts_metadata4("design:paramtypes", [
-    typeof PrismaLike === "undefined" ? Object : PrismaLike
+    typeof Pick === "undefined" ? Object : Pick
   ])
 ], PrismaMfaAdapter);
 
 // src/prisma-plan-catalog-import-sink.ts
-import { Inject as Inject5, Injectable as Injectable6 } from "@nestjs/common";
+import { Inject as Inject5, Injectable as Injectable6, Optional } from "@nestjs/common";
+
+// src/prisma-plan-binding.ts
+var PRISMA_SCHEMA_OPTIONS_TOKEN = /* @__PURE__ */ Symbol.for("saasicat/adapter-prisma/PrismaSchemaOptions");
+var DEFAULT_SCHEMA_OPTIONS = {
+  planBinding: {
+    mode: "legacy-plan-key"
+  },
+  delegates: {
+    catalogPlanVersion: "planVersion",
+    entitlementPlanVersion: "planVersion"
+  },
+  planVersionFields: {
+    catalog: {
+      validityWindows: false,
+      endsAt: false
+    },
+    entitlement: {
+      validityWindows: false,
+      endsAt: false
+    }
+  },
+  tenantSubscription: {
+    delegate: "subscription",
+    subscriptionBundleDelegate: false,
+    synchronizePlanVersion: false,
+    atomicOnboardingSelection: false,
+    activeVersionSelection: "latest-live",
+    withEndsAt: false
+  }
+};
+function resolvePrismaSchemaOptions(options) {
+  const mode = options?.planBinding?.mode ?? "legacy-plan-key";
+  const projectKey = options?.planBinding?.projectKey;
+  if (mode === "normalized-plan-id" && !projectKey?.trim()) {
+    throw new Error("Prisma plan binding mode 'normalized-plan-id' requires a non-empty projectKey.");
+  }
+  const sharedFields = options?.planVersionFields;
+  const catalogFields = sharedFields?.catalog;
+  const entitlementFields = sharedFields?.entitlement;
+  return {
+    planBinding: {
+      mode,
+      ...projectKey ? {
+        projectKey
+      } : {}
+    },
+    delegates: {
+      catalogPlanVersion: options?.delegates?.catalogPlanVersion ?? DEFAULT_SCHEMA_OPTIONS.delegates.catalogPlanVersion,
+      entitlementPlanVersion: options?.delegates?.entitlementPlanVersion ?? DEFAULT_SCHEMA_OPTIONS.delegates.entitlementPlanVersion
+    },
+    planVersionFields: {
+      catalog: {
+        validityWindows: catalogFields?.validityWindows ?? sharedFields?.validityWindows ?? false,
+        endsAt: catalogFields?.endsAt ?? sharedFields?.endsAt ?? false
+      },
+      entitlement: {
+        validityWindows: entitlementFields?.validityWindows ?? sharedFields?.validityWindows ?? false,
+        endsAt: entitlementFields?.endsAt ?? sharedFields?.endsAt ?? false
+      }
+    },
+    tenantSubscription: {
+      delegate: options?.tenantSubscription?.delegate ?? DEFAULT_SCHEMA_OPTIONS.tenantSubscription.delegate,
+      subscriptionBundleDelegate: options?.tenantSubscription?.subscriptionBundleDelegate ?? DEFAULT_SCHEMA_OPTIONS.tenantSubscription.subscriptionBundleDelegate,
+      synchronizePlanVersion: options?.tenantSubscription?.synchronizePlanVersion ?? DEFAULT_SCHEMA_OPTIONS.tenantSubscription.synchronizePlanVersion,
+      atomicOnboardingSelection: options?.tenantSubscription?.atomicOnboardingSelection ?? DEFAULT_SCHEMA_OPTIONS.tenantSubscription.atomicOnboardingSelection,
+      activeVersionSelection: options?.tenantSubscription?.activeVersionSelection ?? DEFAULT_SCHEMA_OPTIONS.tenantSubscription.activeVersionSelection,
+      withEndsAt: options?.tenantSubscription?.withEndsAt ?? DEFAULT_SCHEMA_OPTIONS.tenantSubscription.withEndsAt
+    }
+  };
+}
+__name(resolvePrismaSchemaOptions, "resolvePrismaSchemaOptions");
+function createPrismaPlanBindingResolver(options) {
+  const resolved = resolvePrismaSchemaOptions({
+    planBinding: options
+  }).planBinding;
+  return {
+    mode: resolved.mode,
+    projectKey: resolved.projectKey,
+    async toStoragePlanId(client, planKey, projectKey) {
+      if (resolved.mode === "legacy-plan-key") return planKey;
+      const scope = resolveProjectKey(resolved.projectKey, projectKey);
+      const plan = await asPlanIdentityClient(client).plan.findFirst({
+        where: {
+          projectKey: scope,
+          planKey,
+          deletedAt: null
+        }
+      });
+      if (!plan) {
+        throw new Error(`Plan '${planKey}' not found in project '${scope}'.`);
+      }
+      return plan.id;
+    },
+    async toPlanKey(client, storedPlanId, projectKey) {
+      if (resolved.mode === "legacy-plan-key") return storedPlanId;
+      const scope = resolveProjectKey(resolved.projectKey, projectKey);
+      const plan = await asPlanIdentityClient(client).plan.findUnique({
+        where: {
+          id: storedPlanId
+        }
+      });
+      if (!plan || plan.projectKey !== scope) {
+        throw new Error(`Plan id '${storedPlanId}' not found in project '${scope}'.`);
+      }
+      return plan.planKey;
+    }
+  };
+}
+__name(createPrismaPlanBindingResolver, "createPrismaPlanBindingResolver");
+function getPrismaDelegate(client, delegateName) {
+  const delegate = client?.[delegateName];
+  if (!delegate || typeof delegate !== "object") {
+    throw new Error(`Prisma client has no '${delegateName}' delegate.`);
+  }
+  return delegate;
+}
+__name(getPrismaDelegate, "getPrismaDelegate");
+function resolveProjectKey(configured, requested) {
+  const projectKey = requested ?? configured;
+  if (!projectKey) {
+    throw new Error("Prisma plan binding mode 'normalized-plan-id' requires a projectKey.");
+  }
+  if (configured && requested && configured !== requested) {
+    throw new Error(`Prisma plan binding is configured for project '${configured}', not '${requested}'.`);
+  }
+  return projectKey;
+}
+__name(resolveProjectKey, "resolveProjectKey");
+function asPlanIdentityClient(client) {
+  if (!client || typeof client !== "object" || !("plan" in client)) {
+    throw new Error("Prisma client has no 'plan' delegate.");
+  }
+  return client;
+}
+__name(asPlanIdentityClient, "asPlanIdentityClient");
+
+// src/prisma-plan-catalog-import-sink.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);
@@ -319,11 +456,23 @@ var PrismaPlanCatalogImportSink = class {
     __name(this, "PrismaPlanCatalogImportSink");
   }
   prisma;
-  constructor(prisma) {
+  binding;
+  delegateName;
+  constructor(prisma, options) {
     this.prisma = prisma;
+    const schema = resolvePrismaSchemaOptions(options);
+    this.binding = createPrismaPlanBindingResolver(options?.planBinding);
+    this.delegateName = schema.delegates.catalogPlanVersion;
+  }
+  db() {
+    return this.prisma;
   }
   async upsertPlan(input) {
-    const existing = await this.prisma.plan.findFirst({
+    if (this.binding.mode === "normalized-plan-id" && this.binding.projectKey !== input.projectKey) {
+      throw new Error(`Prisma plan binding is configured for project '${this.binding.projectKey}', not '${input.projectKey}'.`);
+    }
+    const db = this.db();
+    const existing = await db.plan.findFirst({
       where: {
         projectKey: input.projectKey,
         planKey: input.planKey
@@ -333,7 +482,7 @@ var PrismaPlanCatalogImportSink = class {
       created: false,
       skipReason: "exists"
     };
-    await this.prisma.plan.create({
+    await db.plan.create({
       data: {
         projectKey: input.projectKey,
         planKey: input.planKey,
@@ -347,9 +496,11 @@ var PrismaPlanCatalogImportSink = class {
     };
   }
   async upsertPlanVersion(input) {
-    const existing = await this.prisma.planVersion.findFirst({
+    const planVersion = this.planVersions();
+    const storedPlanId = await this.binding.toStoragePlanId(this.prisma, input.planKey);
+    const existing = await planVersion.findFirst({
       where: {
-        planId: input.planKey,
+        planId: storedPlanId,
         version: input.version
       }
     });
@@ -359,9 +510,9 @@ var PrismaPlanCatalogImportSink = class {
     };
     const now = /* @__PURE__ */ new Date();
     if (input.publish) {
-      await this.prisma.planVersion.updateMany({
+      await planVersion.updateMany({
         where: {
-          planId: input.planKey,
+          planId: storedPlanId,
           publishedAt: {
             not: null
           },
@@ -375,9 +526,9 @@ var PrismaPlanCatalogImportSink = class {
         }
       });
     }
-    await this.prisma.planVersion.create({
+    await planVersion.create({
       data: {
-        planId: input.planKey,
+        planId: storedPlanId,
         version: input.version,
         features: input.features,
         quotas: input.quotas,
@@ -392,8 +543,12 @@ var PrismaPlanCatalogImportSink = class {
       created: true
     };
   }
+  planVersions() {
+    return getPrismaDelegate(this.prisma, this.delegateName);
+  }
   async upsertFeatureCatalogEntry(input) {
-    const existing = await this.prisma.featureCatalogEntry.findFirst({
+    const db = this.db();
+    const existing = await db.featureCatalogEntry.findFirst({
       where: {
         projectKey: input.projectKey,
         featureKey: input.featureKey
@@ -403,7 +558,7 @@ var PrismaPlanCatalogImportSink = class {
       created: false,
       skipReason: "exists"
     };
-    await this.prisma.featureCatalogEntry.create({
+    await db.featureCatalogEntry.create({
       data: {
         projectKey: input.projectKey,
         featureKey: input.featureKey,
@@ -422,14 +577,17 @@ var PrismaPlanCatalogImportSink = class {
 PrismaPlanCatalogImportSink = _ts_decorate6([
   Injectable6(),
   _ts_param5(0, Inject5(PRISMA_CLIENT_TOKEN)),
+  _ts_param5(1, Optional()),
+  _ts_param5(1, Inject5(PRISMA_SCHEMA_OPTIONS_TOKEN)),
   _ts_metadata5("design:type", Function),
   _ts_metadata5("design:paramtypes", [
-    typeof PrismaLike === "undefined" ? Object : PrismaLike
+    typeof PlanCatalogImportClient === "undefined" ? Object : PlanCatalogImportClient,
+    typeof PrismaSchemaOptions === "undefined" ? Object : PrismaSchemaOptions
   ])
 ], PrismaPlanCatalogImportSink);
 
 // src/prisma-plan-catalog-read-sink.ts
-import { Inject as Inject6, Injectable as Injectable7 } from "@nestjs/common";
+import { Inject as Inject6, Injectable as Injectable7, Optional as Optional2 } from "@nestjs/common";
 
 // src/tx.ts
 function resolveClient(client, tx) {
@@ -471,11 +629,25 @@ var PrismaPlanCatalogReadSink = class {
     __name(this, "PrismaPlanCatalogReadSink");
   }
   prisma;
-  constructor(prisma) {
+  binding;
+  delegateName;
+  fields;
+  constructor(prisma, options) {
     this.prisma = prisma;
+    const schema = resolvePrismaSchemaOptions(options);
+    this.binding = createPrismaPlanBindingResolver(options?.planBinding);
+    this.delegateName = schema.delegates.catalogPlanVersion;
+    this.fields = schema.planVersionFields.catalog;
+  }
+  db() {
+    return this.prisma;
   }
   async loadSnapshot(projectKey) {
-    const plans = await this.prisma.plan.findMany({
+    if (this.binding.mode === "normalized-plan-id" && this.binding.projectKey !== projectKey) {
+      throw new Error(`Prisma plan binding is configured for project '${this.binding.projectKey}', not '${projectKey}'.`);
+    }
+    const db = this.db();
+    const plans = await db.plan.findMany({
       where: {
         projectKey,
         deletedAt: null
@@ -484,11 +656,17 @@ var PrismaPlanCatalogReadSink = class {
         sortOrder: "asc"
       }
     });
-    const planKeys = plans.map((plan) => plan.planKey);
-    const livePlanVersions = planKeys.length === 0 ? [] : await this.prisma.planVersion.findMany({
+    const planKeysByStoredId = new Map(plans.map((plan) => [
+      this.binding.mode === "normalized-plan-id" ? plan.id : plan.planKey,
+      plan.planKey
+    ]));
+    const storedPlanIds = [
+      ...planKeysByStoredId.keys()
+    ];
+    const livePlanVersions = storedPlanIds.length === 0 ? [] : await this.planVersions().findMany({
       where: {
         planId: {
-          in: planKeys
+          in: storedPlanIds
         },
         publishedAt: {
           not: null
@@ -496,7 +674,7 @@ var PrismaPlanCatalogReadSink = class {
         supersededAt: null
       }
     });
-    const featureEntries = await this.prisma.featureCatalogEntry.findMany({
+    const featureEntries = await db.featureCatalogEntry.findMany({
       where: {
         projectKey,
         deletedAt: null
@@ -507,17 +685,29 @@ var PrismaPlanCatalogReadSink = class {
     });
     return {
       plans: plans.map(toPlanRow),
-      livePlanVersions: livePlanVersions.map(toPlanVersionRow),
+      livePlanVersions: livePlanVersions.map((row) => {
+        const planKey = planKeysByStoredId.get(row.planId);
+        if (!planKey) {
+          throw new Error(`PlanVersion ${row.id} references plan '${row.planId}' outside project '${projectKey}'.`);
+        }
+        return toPlanVersionRow(row, planKey, this.fields);
+      }),
       featureEntries: featureEntries.map(toFeatureCatalogEntryRow)
     };
   }
+  planVersions() {
+    return getPrismaDelegate(this.prisma, this.delegateName);
+  }
 };
 PrismaPlanCatalogReadSink = _ts_decorate7([
   Injectable7(),
   _ts_param6(0, Inject6(PRISMA_CLIENT_TOKEN)),
+  _ts_param6(1, Optional2()),
+  _ts_param6(1, Inject6(PRISMA_SCHEMA_OPTIONS_TOKEN)),
   _ts_metadata6("design:type", Function),
   _ts_metadata6("design:paramtypes", [
-    typeof PrismaLike === "undefined" ? Object : PrismaLike
+    typeof PlanCatalogReadClient === "undefined" ? Object : PlanCatalogReadClient,
+    typeof PrismaSchemaOptions === "undefined" ? Object : PrismaSchemaOptions
   ])
 ], PrismaPlanCatalogReadSink);
 function toPlanRow(row) {
@@ -535,10 +725,10 @@ function toPlanRow(row) {
   };
 }
 __name(toPlanRow, "toPlanRow");
-function toPlanVersionRow(row) {
-  return {
+function toPlanVersionRow(row, planKey, fields) {
+  const mapped = {
     id: row.id,
-    planId: row.planId,
+    planId: planKey,
     version: row.version,
     baseVersionId: row.baseVersionId,
     publishedAt: row.publishedAt ? row.publishedAt.toISOString() : null,
@@ -546,8 +736,8 @@ function toPlanVersionRow(row) {
     publishedChanges: row.publishedChanges ?? null,
     changeNote: row.changeNote,
     nonRegressive: row.nonRegressive,
-    validFrom: null,
-    validUntil: null,
+    validFrom: fields.validityWindows && row.validFrom ? row.validFrom.toISOString() : null,
+    validUntil: fields.validityWindows && row.validUntil ? row.validUntil.toISOString() : null,
     createdByUserId: row.createdByUserId,
     publishedByUserId: row.publishedByUserId,
     createdAt: row.createdAt.toISOString(),
@@ -558,6 +748,10 @@ function toPlanVersionRow(row) {
     yearlyNet: String(row.yearlyNet),
     marketed: row.marketed
   };
+  if (fields.endsAt) {
+    mapped.endsAt = row.endsAt?.toISOString() ?? null;
+  }
+  return mapped;
 }
 __name(toPlanVersionRow, "toPlanVersionRow");
 function toFeatureCatalogEntryRow(row) {
@@ -590,7 +784,8 @@ function toFeatureCatalogEntryRow(row) {
 __name(toFeatureCatalogEntryRow, "toFeatureCatalogEntryRow");
 
 // src/prisma-plan-version.repository.ts
-import { Inject as Inject7, Injectable as Injectable8 } from "@nestjs/common";
+import { Inject as Inject7, Injectable as Injectable8, Optional as Optional3 } from "@nestjs/common";
+import { buildActivePlanVersionWhere } from "@saasicat/types";
 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);
@@ -613,14 +808,29 @@ var PrismaPlanVersionRepository = class {
     __name(this, "PrismaPlanVersionRepository");
   }
   prisma;
-  constructor(prisma) {
+  findActive;
+  binding;
+  delegateName;
+  fields;
+  constructor(prisma, options) {
     this.prisma = prisma;
+    const schema = resolvePrismaSchemaOptions(options);
+    this.binding = createPrismaPlanBindingResolver(options?.planBinding);
+    this.delegateName = schema.delegates.entitlementPlanVersion;
+    this.fields = schema.planVersionFields.entitlement;
+    if (this.fields.validityWindows) {
+      this.findActive = (planId, asOf = /* @__PURE__ */ new Date(), tx) => this.findActivePlanVersion(planId, asOf, tx);
+    }
+  }
+  db(tx) {
+    return tx ?? this.prisma;
   }
   async findLatestLive(planId, tx) {
-    const db = resolveClient(this.prisma, tx);
-    const row = await db.planVersion.findFirst({
+    const db = this.db(tx);
+    const storedPlanId = await this.binding.toStoragePlanId(db, planId);
+    const row = await this.versions(db).findFirst({
       where: {
-        planId,
+        planId: storedPlanId,
         publishedAt: {
           not: null
         },
@@ -631,8 +841,40 @@ var PrismaPlanVersionRepository = class {
       }
     });
     if (!row) return null;
+    return this.toRecord(db, row);
+  }
+  async findActivePlanVersion(planId, asOf, tx) {
+    const db = this.db(tx);
+    const storedPlanId = await this.binding.toStoragePlanId(db, planId);
+    const activeWhere = this.fields.endsAt ? buildActivePlanVersionWhere(asOf, {
+      withEndsAt: true
+    }) : buildActivePlanVersionWhere(asOf);
+    const row = await this.versions(db).findFirst({
+      where: {
+        planId: storedPlanId,
+        ...activeWhere
+      },
+      orderBy: [
+        {
+          validFrom: {
+            sort: "desc",
+            nulls: "last"
+          }
+        },
+        {
+          version: "desc"
+        }
+      ]
+    });
+    if (!row) return null;
+    return this.toRecord(db, row);
+  }
+  versions(client) {
+    return getPrismaDelegate(client, this.delegateName);
+  }
+  async toRecord(client, row) {
     return {
-      planId: row.planId,
+      planId: await this.binding.toPlanKey(client, row.planId),
       quotas: toQuotaMap(row.quotas),
       features: toStringArray(row.features)
     };
@@ -641,9 +883,12 @@ var PrismaPlanVersionRepository = class {
 PrismaPlanVersionRepository = _ts_decorate8([
   Injectable8(),
   _ts_param7(0, Inject7(PRISMA_CLIENT_TOKEN)),
+  _ts_param7(1, Optional3()),
+  _ts_param7(1, Inject7(PRISMA_SCHEMA_OPTIONS_TOKEN)),
   _ts_metadata7("design:type", Function),
   _ts_metadata7("design:paramtypes", [
-    typeof PrismaLike === "undefined" ? Object : PrismaLike
+    typeof PlanVersionRepositoryClient === "undefined" ? Object : PlanVersionRepositoryClient,
+    typeof PrismaSchemaOptions === "undefined" ? Object : PrismaSchemaOptions
   ])
 ], PrismaPlanVersionRepository);
 
@@ -1084,7 +1329,7 @@ PrismaPromoSubscriptionLookup = _ts_decorate12([
 ], PrismaPromoSubscriptionLookup);
 
 // src/prisma-subscription.repository.ts
-import { Inject as Inject12, Injectable as Injectable13 } from "@nestjs/common";
+import { Inject as Inject12, Injectable as Injectable13, Optional as Optional4 } 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);
@@ -1111,19 +1356,35 @@ var PrismaSubscriptionRepository = class {
     __name(this, "PrismaSubscriptionRepository");
   }
   prisma;
-  constructor(prisma) {
+  countByBundleVersionId;
+  binding;
+  planVersionDelegateName;
+  subscriptionDelegateName;
+  subscriptionBundleDelegateName;
+  constructor(prisma, options) {
     this.prisma = prisma;
+    const schema = resolvePrismaSchemaOptions(options);
+    this.binding = createPrismaPlanBindingResolver(options?.planBinding);
+    this.planVersionDelegateName = schema.delegates.entitlementPlanVersion;
+    this.subscriptionDelegateName = schema.tenantSubscription.delegate;
+    this.subscriptionBundleDelegateName = schema.tenantSubscription.subscriptionBundleDelegate;
+    if (this.subscriptionBundleDelegateName) {
+      this.countByBundleVersionId = (bundleVersionId) => this.countActiveBundleBindings(bundleVersionId);
+    }
+  }
+  db(tx) {
+    return tx ?? this.prisma;
   }
   async findByTenantId(tenantId) {
-    return this.loadByTenantId(this.prisma, tenantId);
+    return this.loadByTenantId(this.db(), tenantId);
   }
   async findByTenantIdLocked(tenantId, tx) {
-    const db = resolveClient(this.prisma, tx);
+    const db = this.db(tx);
     await db.$queryRaw`SELECT id FROM subscriptions WHERE "tenantId" = ${tenantId} FOR UPDATE`;
     return this.loadByTenantId(db, tenantId);
   }
   async countByPlanVersionId(planVersionId) {
-    return this.prisma.subscription.count({
+    return this.subscriptions(this.db()).count({
       where: {
         OR: [
           {
@@ -1136,22 +1397,72 @@ var PrismaSubscriptionRepository = class {
       }
     });
   }
-  async countActiveByPlanKey(_projectKey) {
-    const rows = await this.prisma.subscription.findMany({
+  async countActiveByPlanKey(projectKey) {
+    const db = this.db();
+    const subscriptions = await this.subscriptions(db).findMany({
       where: {
         status: {
           in: ACTIVE_STATUSES
         }
+      },
+      select: {
+        planVersionId: true
+      }
+    });
+    const versionIds = [
+      ...new Set(subscriptions.map((subscription) => subscription.planVersionId))
+    ];
+    if (versionIds.length === 0) return {};
+    const planVersions = await this.planVersions(db).findMany({
+      where: {
+        id: {
+          in: versionIds
+        }
+      },
+      select: {
+        id: true,
+        planId: true
       }
     });
+    const planVersionById = new Map(planVersions.map((planVersion) => [
+      planVersion.id,
+      planVersion
+    ]));
+    const storedPlanIds = [
+      ...new Set(planVersions.map((planVersion) => planVersion.planId))
+    ];
+    const planKeyByStoredId = await this.planKeysForProject(db, storedPlanIds, projectKey);
     const counts = {};
-    for (const row of rows) {
-      counts[row.plan] = (counts[row.plan] ?? 0) + 1;
+    for (const subscription of subscriptions) {
+      const planVersion = planVersionById.get(subscription.planVersionId);
+      const planKey = planVersion ? planKeyByStoredId.get(planVersion.planId) : void 0;
+      if (!planKey) continue;
+      counts[planKey] = (counts[planKey] ?? 0) + 1;
     }
     return counts;
   }
+  async countActiveBundleBindings(bundleVersionId) {
+    if (!this.subscriptionBundleDelegateName) {
+      throw new Error("SubscriptionBundle counting is not configured.");
+    }
+    return getPrismaDelegate(this.prisma, this.subscriptionBundleDelegateName).count({
+      where: {
+        bundleVersionId,
+        OR: [
+          {
+            canceledAt: null
+          },
+          {
+            canceledEffectiveAt: {
+              gt: /* @__PURE__ */ new Date()
+            }
+          }
+        ]
+      }
+    });
+  }
   async loadByTenantId(db, tenantId) {
-    const row = await db.subscription.findUnique({
+    const row = await this.subscriptions(db).findUnique({
       where: {
         tenantId
       }
@@ -1160,10 +1471,7 @@ var PrismaSubscriptionRepository = class {
     return this.toRecord(db, row);
   }
   async toRecord(db, row) {
-    if (!row.planVersionId) {
-      throw new Error(`Subscription ${row.id} binds no planVersionId (businessType-only composition). The shipped @saasicat/adapter-prisma SubscriptionRepository does not support BusinessType aggregation \u2014 provide a custom SubscriptionRepository adapter.`);
-    }
-    const planVersion = await db.planVersion.findUnique({
+    const planVersion = await this.planVersions(db).findUnique({
       where: {
         id: row.planVersionId
       }
@@ -1171,10 +1479,13 @@ var PrismaSubscriptionRepository = class {
     if (!planVersion) {
       throw new Error(`Subscription ${row.id} references missing PlanVersion ${row.planVersionId}.`);
     }
+    const planKey = await this.binding.toPlanKey(db, planVersion.planId);
     return {
       id: row.id,
       tenantId: row.tenantId,
-      plan: row.plan,
+      // The concrete PlanVersion is authoritative. This also normalizes
+      // legacy rows whose denormalized `Subscription.plan` drifted.
+      plan: planKey,
       status: row.status,
       isPilot: row.isPilot,
       trialEntitlementPlan: row.trialEntitlementPlan,
@@ -1183,19 +1494,78 @@ var PrismaSubscriptionRepository = class {
       customLimits: row.customLimits ?? null,
       planVersionId: row.planVersionId,
       planVersion: {
-        planId: planVersion.planId,
+        planId: planKey,
         quotas: toQuotaMap(planVersion.quotas),
         features: toStringArray(planVersion.features)
       }
     };
   }
+  planVersions(client) {
+    return getPrismaDelegate(client, this.planVersionDelegateName);
+  }
+  subscriptions(client) {
+    return getPrismaDelegate(client, this.subscriptionDelegateName);
+  }
+  async planKeysForProject(db, storedPlanIds, projectKey) {
+    if (storedPlanIds.length === 0) return /* @__PURE__ */ new Map();
+    if (this.binding.mode === "normalized-plan-id") {
+      if (this.binding.projectKey && this.binding.projectKey !== projectKey) {
+        throw new Error(`Prisma plan binding is configured for project '${this.binding.projectKey}', not '${projectKey}'.`);
+      }
+      const plans2 = await db.plan.findMany({
+        where: {
+          projectKey,
+          id: {
+            in: storedPlanIds
+          }
+        },
+        select: {
+          id: true,
+          planKey: true
+        }
+      });
+      return new Map(plans2.map((plan) => [
+        plan.id,
+        plan.planKey
+      ]));
+    }
+    const plans = await db.plan.findMany({
+      where: {
+        planKey: {
+          in: storedPlanIds
+        }
+      },
+      select: {
+        projectKey: true,
+        planKey: true
+      }
+    });
+    const projectsByPlanKey = /* @__PURE__ */ new Map();
+    for (const plan of plans) {
+      const projects = projectsByPlanKey.get(plan.planKey) ?? /* @__PURE__ */ new Set();
+      projects.add(plan.projectKey);
+      projectsByPlanKey.set(plan.planKey, projects);
+    }
+    return new Map(storedPlanIds.flatMap((planKey) => {
+      const projects = projectsByPlanKey.get(planKey);
+      return projects?.size === 1 && projects.has(projectKey) ? [
+        [
+          planKey,
+          planKey
+        ]
+      ] : [];
+    }));
+  }
 };
 PrismaSubscriptionRepository = _ts_decorate13([
   Injectable13(),
   _ts_param12(0, Inject12(PRISMA_CLIENT_TOKEN)),
+  _ts_param12(1, Optional4()),
+  _ts_param12(1, Inject12(PRISMA_SCHEMA_OPTIONS_TOKEN)),
   _ts_metadata12("design:type", Function),
   _ts_metadata12("design:paramtypes", [
-    typeof PrismaLike === "undefined" ? Object : PrismaLike
+    typeof SubscriptionRepositoryClient === "undefined" ? Object : SubscriptionRepositoryClient,
+    typeof PrismaSchemaOptions === "undefined" ? Object : PrismaSchemaOptions
   ])
 ], PrismaSubscriptionRepository);
 
@@ -1307,7 +1677,8 @@ var PrismaTransactionRunner = class {
     this.prisma = prisma;
   }
   async run(fn) {
-    return this.prisma.$transaction((tx) => fn(tx));
+    const transaction = this.prisma.$transaction.bind(this.prisma);
+    return transaction((tx) => fn(tx));
   }
 };
 PrismaTransactionRunner = _ts_decorate15([
@@ -1315,7 +1686,7 @@ PrismaTransactionRunner = _ts_decorate15([
   _ts_param14(0, Inject14(PRISMA_CLIENT_TOKEN)),
   _ts_metadata14("design:type", Function),
   _ts_metadata14("design:paramtypes", [
-    typeof PrismaLike === "undefined" ? Object : PrismaLike
+    typeof Record === "undefined" ? Object : Record
   ])
 ], PrismaTransactionRunner);
 
@@ -1366,8 +1737,8 @@ function prismaPersistence(options) {
       superAdminProvisioning: buildProvisioning(client, options.passwordHasher)
     },
     entitlement: {
-      subscriptionRepository: provide((prisma) => new PrismaSubscriptionRepository(prisma)),
-      planVersionRepository: provide((prisma) => new PrismaPlanVersionRepository(prisma))
+      subscriptionRepository: provide((prisma) => new PrismaSubscriptionRepository(prisma, options.schema)),
+      planVersionRepository: provide((prisma) => new PrismaPlanVersionRepository(prisma, options.schema))
     },
     promo: {
       promoCodeRepository: provide((prisma) => new PrismaPromoCodeRepository(prisma)),
@@ -1376,8 +1747,8 @@ function prismaPersistence(options) {
       subscriptionLookup: provide((prisma) => new PrismaPromoSubscriptionLookup(prisma)),
       revenueAggregator: new ZeroPromoRevenueDeductionAggregator()
     },
-    planCatalogReadSink: provide((prisma) => new PrismaPlanCatalogReadSink(prisma)),
-    planCatalogImportSink: provide((prisma) => new PrismaPlanCatalogImportSink(prisma))
+    planCatalogReadSink: provide((prisma) => new PrismaPlanCatalogReadSink(prisma, options.schema)),
+    planCatalogImportSink: provide((prisma) => new PrismaPlanCatalogImportSink(prisma, options.schema))
   };
 }
 __name(prismaPersistence, "prismaPersistence");
@@ -1417,25 +1788,2746 @@ function buildProvisioning(client, hasher) {
   return new PrismaSuperAdminBootstrapAdapter(client, hasher);
 }
 __name(buildProvisioning, "buildProvisioning");
+
+// src/prisma-subscription-bundle.repository.ts
+import { Inject as Inject15, Injectable as Injectable17 } from "@nestjs/common";
+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_metadata15(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata15, "_ts_metadata");
+function _ts_param15(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param15, "_ts_param");
+var PrismaSubscriptionBundleRepository = class {
+  static {
+    __name(this, "PrismaSubscriptionBundleRepository");
+  }
+  prisma;
+  constructor(prisma) {
+    this.prisma = prisma;
+  }
+  db(tx) {
+    return tx ?? this.prisma;
+  }
+  async listBySubscription(subscriptionId) {
+    const rows = await this.db().subscriptionBundle.findMany({
+      where: {
+        subscriptionId
+      },
+      orderBy: {
+        startedAt: "desc"
+      }
+    });
+    return rows.map(toRecord3);
+  }
+  async findById(subscriptionBundleId) {
+    const row = await this.db().subscriptionBundle.findUnique({
+      where: {
+        id: subscriptionBundleId
+      }
+    });
+    return row ? toRecord3(row) : null;
+  }
+  async listActiveBySubscription(subscriptionId, asOf = /* @__PURE__ */ new Date()) {
+    const rows = await this.db().subscriptionBundle.findMany({
+      where: {
+        subscriptionId,
+        OR: [
+          {
+            canceledAt: null
+          },
+          {
+            canceledEffectiveAt: {
+              gt: asOf
+            }
+          }
+        ]
+      },
+      orderBy: {
+        startedAt: "desc"
+      }
+    });
+    return rows.map(toRecord3);
+  }
+  async add(data) {
+    const row = await this.db().subscriptionBundle.create({
+      data: {
+        subscriptionId: data.subscriptionId,
+        bundleVersionId: data.bundleVersionId,
+        startedAt: data.startedAt,
+        minimumTermEndsAt: data.minimumTermEndsAt ?? null
+      }
+    });
+    return toRecord3(row);
+  }
+  async cancel(subscriptionBundleId, data) {
+    const row = await this.db().subscriptionBundle.update({
+      where: {
+        id: subscriptionBundleId
+      },
+      data: {
+        canceledAt: data.canceledAt,
+        canceledEffectiveAt: data.canceledEffectiveAt
+      }
+    });
+    return toRecord3(row);
+  }
+  async reactivate(subscriptionBundleId) {
+    const row = await this.db().subscriptionBundle.update({
+      where: {
+        id: subscriptionBundleId
+      },
+      data: {
+        canceledAt: null,
+        canceledEffectiveAt: null
+      }
+    });
+    return toRecord3(row);
+  }
+  async countActiveByBundleVersionId(bundleVersionId, asOf = /* @__PURE__ */ new Date()) {
+    return this.db().subscriptionBundle.count({
+      where: {
+        bundleVersionId,
+        OR: [
+          {
+            canceledAt: null
+          },
+          {
+            canceledEffectiveAt: {
+              gt: asOf
+            }
+          }
+        ]
+      }
+    });
+  }
+};
+PrismaSubscriptionBundleRepository = _ts_decorate17([
+  Injectable17(),
+  _ts_param15(0, Inject15(PRISMA_CLIENT_TOKEN)),
+  _ts_metadata15("design:type", Function),
+  _ts_metadata15("design:paramtypes", [
+    typeof SubscriptionBundleClient === "undefined" ? Object : SubscriptionBundleClient
+  ])
+], PrismaSubscriptionBundleRepository);
+function toRecord3(row) {
+  return {
+    id: row.id,
+    subscriptionId: row.subscriptionId,
+    bundleVersionId: row.bundleVersionId,
+    startedAt: row.startedAt,
+    minimumTermEndsAt: row.minimumTermEndsAt,
+    canceledAt: row.canceledAt,
+    canceledEffectiveAt: row.canceledEffectiveAt,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt
+  };
+}
+__name(toRecord3, "toRecord");
+
+// src/prisma-tenant-subscription-write.adapter.ts
+import { Inject as Inject16, Injectable as Injectable18, Optional as Optional5 } from "@nestjs/common";
+import { buildActivePlanVersionWhere as buildActivePlanVersionWhere2 } from "@saasicat/types";
+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");
+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_param16(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param16, "_ts_param");
+var PrismaTenantSubscriptionWriteAdapter = class {
+  static {
+    __name(this, "PrismaTenantSubscriptionWriteAdapter");
+  }
+  prisma;
+  applyOnboardingSelection;
+  schema;
+  planBinding;
+  constructor(prisma, options) {
+    this.prisma = prisma;
+    this.schema = resolvePrismaSchemaOptions(options);
+    this.planBinding = createPrismaPlanBindingResolver(options?.planBinding);
+    this.assertConfiguration();
+    if (this.schema.tenantSubscription.atomicOnboardingSelection) {
+      this.applyOnboardingSelection = (tenantId, input, redeemPromo) => this.applyOnboardingSelectionAtomic(tenantId, input, redeemPromo);
+    }
+  }
+  async changePlanImmediate(tenantId, input) {
+    if (this.schema.tenantSubscription.synchronizePlanVersion) {
+      return this.prisma.$transaction((tx) => this.changePlanImmediateInClient(tx, tenantId, input));
+    }
+    return this.changePlanImmediateInClient(this.prisma, tenantId, input);
+  }
+  async changePlanImmediateInClient(client, tenantId, input) {
+    const subscription = this.subscription(client);
+    const data = {
+      plan: input.planId,
+      billingCycle: input.cycle,
+      pendingPlan: null,
+      pendingBillingCycle: null,
+      pendingEffectiveAt: null,
+      ...input.nextStatus ? {
+        status: input.nextStatus
+      } : {},
+      ...input.periodStart && input.periodEnd ? {
+        currentPeriodStart: input.periodStart,
+        currentPeriodEnd: input.periodEnd
+      } : {},
+      // #17: the platform changePlan path computes the carried-over
+      // trial end and passes it through; null/undefined leaves the
+      // existing trialEndsAt untouched.
+      ...input.trialEndsAt ? {
+        trialEndsAt: input.trialEndsAt
+      } : {}
+    };
+    if (this.schema.tenantSubscription.synchronizePlanVersion) {
+      const current = await subscription.findUnique({
+        where: {
+          tenantId
+        }
+      });
+      if (!current) {
+        throw new Error(`No subscription for tenant ${tenantId}.`);
+      }
+      const storagePlanId = await this.planBinding.toStoragePlanId(client, input.planId);
+      data.planVersionId = await this.findTargetPlanVersionId(client, storagePlanId, input.periodStart ?? /* @__PURE__ */ new Date());
+      if (await this.pendingVersionBelongsToAnotherPlan(client, current.pendingPlanVersionId, storagePlanId)) {
+        Object.assign(data, clearedPendingVersionData());
+      }
+    }
+    const updated = await subscription.update({
+      where: {
+        tenantId
+      },
+      data
+    });
+    return {
+      plan: updated.plan,
+      billingCycle: updated.billingCycle
+    };
+  }
+  async schedulePlanChange(tenantId, input) {
+    await this.subscription(this.prisma).update({
+      where: {
+        tenantId
+      },
+      data: {
+        pendingPlan: input.pendingPlan,
+        pendingBillingCycle: input.pendingBillingCycle,
+        pendingEffectiveAt: input.pendingEffectiveAt
+      }
+    });
+  }
+  async acceptPendingPlanVersion(tenantId, userId, now) {
+    const subscription = this.subscription(this.prisma);
+    const sub = await subscription.findUnique({
+      where: {
+        tenantId
+      }
+    });
+    if (!sub) {
+      throw new Error(`No subscription for tenant ${tenantId}.`);
+    }
+    if (!sub.pendingPlanVersionId) {
+      throw new Error(`No pending PlanVersion for tenant ${tenantId}.`);
+    }
+    const pendingPlanVersionId = sub.pendingPlanVersionId;
+    const claimed = await subscription.updateMany({
+      where: {
+        id: sub.id,
+        pendingPlanVersionId,
+        pendingPlanVersionAccepted: false
+      },
+      data: {
+        pendingPlanVersionAccepted: true,
+        pendingPlanVersionAcceptedAt: now,
+        pendingPlanVersionAcceptedByUserId: userId
+      }
+    });
+    const updated = await subscription.findUnique({
+      where: {
+        id: sub.id
+      }
+    });
+    if (!updated) {
+      throw new Error(`No subscription for tenant ${tenantId}.`);
+    }
+    if (claimed.count === 0 && (updated.pendingPlanVersionId !== pendingPlanVersionId || !updated.pendingPlanVersionAccepted)) {
+      throw new Error(`Pending PlanVersion changed while accepting it for tenant ${tenantId}.`);
+    }
+    return {
+      accepted: true,
+      acceptedAt: updated.pendingPlanVersionAcceptedAt,
+      effectiveAt: updated.pendingPlanVersionEffectiveAt,
+      alreadyAccepted: claimed.count === 0
+    };
+  }
+  async applyOnboardingSelectionAtomic(tenantId, input, redeemPromo) {
+    return this.prisma.$transaction(async (tx) => {
+      const data = {
+        plan: input.planId,
+        billingCycle: input.cycle,
+        pendingPlan: null,
+        pendingBillingCycle: null,
+        pendingEffectiveAt: null,
+        ...clearedPendingVersionData(),
+        ...input.nextStatus ? {
+          status: input.nextStatus
+        } : {},
+        ...input.periodStart && input.periodEnd ? {
+          currentPeriodStart: input.periodStart,
+          currentPeriodEnd: input.periodEnd
+        } : {}
+      };
+      if (this.schema.tenantSubscription.synchronizePlanVersion) {
+        const storagePlanId = await this.planBinding.toStoragePlanId(tx, input.planId);
+        data.planVersionId = await this.findTargetPlanVersionId(tx, storagePlanId, input.periodStart ?? /* @__PURE__ */ new Date());
+      }
+      const updated = await this.subscription(tx).update({
+        where: {
+          tenantId
+        },
+        data
+      });
+      let promoRedemption = null;
+      if (redeemPromo) {
+        promoRedemption = await redeemPromo(tx, updated.id);
+      }
+      return {
+        plan: updated.plan,
+        billingCycle: updated.billingCycle,
+        subscriptionId: updated.id,
+        promoRedemption
+      };
+    });
+  }
+  async cancelSubscription(tenantId, immediate, now) {
+    const subscription = this.subscription(this.prisma);
+    const sub = await subscription.findUnique({
+      where: {
+        tenantId
+      }
+    });
+    if (!sub) {
+      throw new Error(`No subscription for tenant ${tenantId}.`);
+    }
+    const canceledAt = immediate ? now : sub.currentPeriodEnd ?? now;
+    const updated = await subscription.update({
+      where: {
+        tenantId
+      },
+      data: {
+        canceledAt,
+        status: immediate ? "CANCELED" : sub.status
+      }
+    });
+    return {
+      canceledAt: updated.canceledAt,
+      status: updated.status
+    };
+  }
+  subscription(client) {
+    return getPrismaDelegate(client, this.schema.tenantSubscription.delegate);
+  }
+  planVersions(client) {
+    return getPrismaDelegate(client, this.schema.delegates.entitlementPlanVersion);
+  }
+  async findTargetPlanVersionId(client, storagePlanId, asOf) {
+    const activeWindow = this.schema.tenantSubscription.activeVersionSelection === "validity-window";
+    const activeVersionWhere = this.schema.tenantSubscription.withEndsAt ? buildActivePlanVersionWhere2(asOf, {
+      withEndsAt: true
+    }) : buildActivePlanVersionWhere2(asOf);
+    const where = activeWindow ? {
+      planId: storagePlanId,
+      ...activeVersionWhere
+    } : {
+      planId: storagePlanId,
+      publishedAt: {
+        not: null
+      },
+      supersededAt: null,
+      ...this.schema.tenantSubscription.withEndsAt ? {
+        OR: [
+          {
+            endsAt: null
+          },
+          {
+            endsAt: {
+              gt: asOf
+            }
+          }
+        ]
+      } : {}
+    };
+    const target = await this.planVersions(client).findFirst({
+      where,
+      orderBy: activeWindow ? [
+        {
+          validFrom: {
+            sort: "desc",
+            nulls: "last"
+          }
+        },
+        {
+          version: "desc"
+        }
+      ] : {
+        version: "desc"
+      }
+    });
+    if (!target) {
+      throw new Error(`No active PlanVersion for plan '${storagePlanId}'.`);
+    }
+    return target.id;
+  }
+  async pendingVersionBelongsToAnotherPlan(client, pendingPlanVersionId, targetStoragePlanId) {
+    if (!pendingPlanVersionId) return false;
+    const pending = await this.planVersions(client).findUnique({
+      where: {
+        id: pendingPlanVersionId
+      }
+    });
+    return !pending || pending.planId !== targetStoragePlanId;
+  }
+  assertConfiguration() {
+    if (!this.schema.tenantSubscription.synchronizePlanVersion) return;
+    const entitlementFields = this.schema.planVersionFields.entitlement;
+    if (this.schema.tenantSubscription.activeVersionSelection === "validity-window" && !entitlementFields.validityWindows) {
+      throw new Error("tenantSubscription.activeVersionSelection='validity-window' requires planVersionFields.entitlement.validityWindows=true.");
+    }
+    if (this.schema.tenantSubscription.withEndsAt && !entitlementFields.endsAt) {
+      throw new Error("tenantSubscription.withEndsAt=true requires planVersionFields.entitlement.endsAt=true.");
+    }
+  }
+};
+PrismaTenantSubscriptionWriteAdapter = _ts_decorate18([
+  Injectable18(),
+  _ts_param16(0, Inject16(PRISMA_CLIENT_TOKEN)),
+  _ts_param16(1, Optional5()),
+  _ts_param16(1, Inject16(PRISMA_SCHEMA_OPTIONS_TOKEN)),
+  _ts_metadata16("design:type", Function),
+  _ts_metadata16("design:paramtypes", [
+    typeof TransactionalPrismaClient === "undefined" ? Object : TransactionalPrismaClient,
+    typeof PrismaSchemaOptions === "undefined" ? Object : PrismaSchemaOptions
+  ])
+], PrismaTenantSubscriptionWriteAdapter);
+function clearedPendingVersionData() {
+  return {
+    pendingPlanVersionId: null,
+    pendingPlanVersionEffectiveAt: null,
+    pendingPlanVersionAccepted: false,
+    pendingPlanVersionAcceptedAt: null,
+    pendingPlanVersionAcceptedByUserId: null,
+    pendingPlanVersionNotifiedAt: null,
+    pendingPlanVersionReminderSentAt: null
+  };
+}
+__name(clearedPendingVersionData, "clearedPendingVersionData");
+
+// src/prisma-plan.repository.ts
+import { Inject as Inject17, Injectable as Injectable19, Optional as Optional6 } from "@nestjs/common";
+import { buildActivePlanVersionWhere as buildActivePlanVersionWhere3 } from "@saasicat/types";
+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");
+function _ts_metadata17(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata17, "_ts_metadata");
+function _ts_param17(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param17, "_ts_param");
+var PrismaPlanRepository = class {
+  static {
+    __name(this, "PrismaPlanRepository");
+  }
+  prisma;
+  binding;
+  delegateName;
+  fields;
+  constructor(prisma, options) {
+    this.prisma = prisma;
+    const schema = resolvePrismaSchemaOptions(options);
+    this.binding = createPrismaPlanBindingResolver(options?.planBinding);
+    this.delegateName = schema.delegates.catalogPlanVersion;
+    this.fields = schema.planVersionFields.catalog;
+  }
+  db(tx) {
+    return tx ?? this.prisma;
+  }
+  versions(client) {
+    return getPrismaDelegate(client, this.delegateName);
+  }
+  // ─── Stem operations (Pack 1) ───
+  async list(filter) {
+    const excludeDeleted = filter.excludeDeleted ?? true;
+    const db = this.db();
+    let publishedKeys = null;
+    if (filter.onlyPublished) {
+      if (this.binding.mode === "legacy-plan-key") {
+        const projectPlans = await db.plan.findMany({
+          where: {
+            projectKey: filter.projectKey,
+            ...excludeDeleted ? {
+              deletedAt: null
+            } : {}
+          }
+        });
+        const candidateKeys = [
+          ...new Set(projectPlans.map((plan) => plan.planKey))
+        ];
+        const allMatchingPlans = candidateKeys.length === 0 ? [] : await db.plan.findMany({
+          where: {
+            planKey: {
+              in: candidateKeys
+            }
+          }
+        });
+        const projectsByKey = /* @__PURE__ */ new Map();
+        for (const plan of allMatchingPlans) {
+          const projects = projectsByKey.get(plan.planKey) ?? /* @__PURE__ */ new Set();
+          projects.add(plan.projectKey);
+          projectsByKey.set(plan.planKey, projects);
+        }
+        const unambiguousKeys = candidateKeys.filter((planKey) => projectsByKey.get(planKey)?.size === 1);
+        const live = await this.versions(db).findMany({
+          where: {
+            planId: {
+              in: unambiguousKeys
+            },
+            publishedAt: {
+              not: null
+            },
+            supersededAt: null
+          }
+        });
+        publishedKeys = [
+          ...new Set(live.map((version) => version.planId))
+        ];
+      } else {
+        const projectPlans = await db.plan.findMany({
+          where: {
+            projectKey: filter.projectKey,
+            ...excludeDeleted ? {
+              deletedAt: null
+            } : {}
+          }
+        });
+        const planKeyById = new Map(projectPlans.map((plan) => [
+          plan.id,
+          plan.planKey
+        ]));
+        const live = await this.versions(db).findMany({
+          where: {
+            planId: {
+              in: [
+                ...planKeyById.keys()
+              ]
+            },
+            publishedAt: {
+              not: null
+            },
+            supersededAt: null
+          }
+        });
+        publishedKeys = [
+          ...new Set(live.flatMap((version) => {
+            const planKey = planKeyById.get(version.planId);
+            return planKey ? [
+              planKey
+            ] : [];
+          }))
+        ];
+      }
+    }
+    const rows = await db.plan.findMany({
+      where: {
+        projectKey: filter.projectKey,
+        ...excludeDeleted ? {
+          deletedAt: null
+        } : {},
+        ...publishedKeys ? {
+          planKey: {
+            in: publishedKeys
+          }
+        } : {}
+      },
+      orderBy: [
+        {
+          sortOrder: "asc"
+        },
+        {
+          planKey: "asc"
+        }
+      ]
+    });
+    return rows.map(toPlanRow2);
+  }
+  async findById(planId) {
+    const row = await this.db().plan.findUnique({
+      where: {
+        id: planId
+      }
+    });
+    return row ? toPlanRow2(row) : null;
+  }
+  async findByKey(projectKey, planKey) {
+    const row = await this.db().plan.findFirst({
+      where: {
+        projectKey,
+        planKey,
+        deletedAt: null
+      }
+    });
+    return row ? toPlanRow2(row) : null;
+  }
+  async create(data) {
+    const created = await this.db().plan.create({
+      data: {
+        projectKey: data.projectKey,
+        planKey: data.planKey,
+        label: data.label,
+        description: data.description ?? null,
+        icon: data.icon ?? null,
+        sortOrder: data.sortOrder ?? 0
+      }
+    });
+    return toPlanRow2(created);
+  }
+  async update(planId, data) {
+    const updated = await this.db().plan.update({
+      where: {
+        id: planId
+      },
+      data: {
+        ...data.label !== void 0 ? {
+          label: data.label
+        } : {},
+        ...data.description !== void 0 ? {
+          description: data.description
+        } : {},
+        ...data.icon !== void 0 ? {
+          icon: data.icon
+        } : {},
+        ...data.sortOrder !== void 0 ? {
+          sortOrder: data.sortOrder
+        } : {}
+      }
+    });
+    return toPlanRow2(updated);
+  }
+  async softDelete(planId) {
+    await this.db().plan.update({
+      where: {
+        id: planId
+      },
+      data: {
+        deletedAt: /* @__PURE__ */ new Date()
+      }
+    });
+  }
+  async hardDelete(planId) {
+    await this.db().plan.deleteMany({
+      where: {
+        id: planId
+      }
+    });
+  }
+  // ─── Lifecycle operations (Pack 2a) — keyed by planKey ───
+  async listVersions(planKey) {
+    const db = this.db();
+    const storedPlanId = await this.binding.toStoragePlanId(db, planKey);
+    const rows = await this.versions(db).findMany({
+      where: {
+        planId: storedPlanId
+      },
+      orderBy: {
+        version: "asc"
+      }
+    });
+    return rows.map((row) => this.toPlanVersionRow(row, planKey));
+  }
+  async findVersionById(versionId) {
+    const db = this.db();
+    const row = await this.versions(db).findUnique({
+      where: {
+        id: versionId
+      }
+    });
+    return row ? this.toPlanVersionRow(row, await this.binding.toPlanKey(db, row.planId)) : null;
+  }
+  async findCurrentDraft(planKey) {
+    const db = this.db();
+    const storedPlanId = await this.binding.toStoragePlanId(db, planKey);
+    const row = await this.versions(db).findFirst({
+      where: {
+        planId: storedPlanId,
+        publishedAt: null
+      }
+    });
+    return row ? this.toPlanVersionRow(row, planKey) : null;
+  }
+  async findLatestLivePlanVersion(planKey, tx) {
+    const db = this.db(tx);
+    const storedPlanId = await this.binding.toStoragePlanId(db, planKey);
+    const row = await this.versions(db).findFirst({
+      where: {
+        planId: storedPlanId,
+        publishedAt: {
+          not: null
+        },
+        supersededAt: null,
+        ...this.fields.endsAt ? {
+          OR: [
+            {
+              endsAt: null
+            },
+            {
+              endsAt: {
+                gt: /* @__PURE__ */ new Date()
+              }
+            }
+          ]
+        } : {}
+      },
+      orderBy: {
+        version: "desc"
+      }
+    });
+    return row ? this.toPlanVersionRow(row, planKey) : null;
+  }
+  async findActivePlanVersion(planKey, asOf = /* @__PURE__ */ new Date(), tx) {
+    if (!this.fields.validityWindows) {
+      throw new Error("findActivePlanVersion requires schema.planVersionFields.catalog.validityWindows=true and the current @saasicat/spec PlanVersion validity columns. Apply the additive schema first, or use findLatestLivePlanVersion for a 0.6-compatible newest-live lookup.");
+    }
+    const db = this.db(tx);
+    const storedPlanId = await this.binding.toStoragePlanId(db, planKey);
+    const activeWhere = this.fields.endsAt ? buildActivePlanVersionWhere3(asOf, {
+      withEndsAt: true
+    }) : buildActivePlanVersionWhere3(asOf);
+    const row = await this.versions(db).findFirst({
+      where: {
+        planId: storedPlanId,
+        ...activeWhere
+      },
+      orderBy: [
+        {
+          validFrom: {
+            sort: "desc",
+            nulls: "last"
+          }
+        },
+        {
+          version: "desc"
+        }
+      ]
+    });
+    return row ? this.toPlanVersionRow(row, planKey) : null;
+  }
+  async createPlanVersionDraft(data) {
+    const planKey = data.planId;
+    const db = this.db();
+    const planVersion = this.versions(db);
+    const storedPlanId = await this.binding.toStoragePlanId(db, planKey);
+    const latest = await planVersion.findFirst({
+      where: {
+        planId: storedPlanId
+      },
+      orderBy: {
+        version: "desc"
+      }
+    });
+    const nextVersion = (latest?.version ?? 0) + 1;
+    const created = await planVersion.create({
+      data: {
+        planId: storedPlanId,
+        version: nextVersion,
+        baseVersionId: data.baseVersionId ?? null,
+        features: data.features,
+        quotas: data.quotas,
+        monthlyNet: data.monthlyNet,
+        yearlyNet: data.yearlyNet,
+        marketed: data.marketed ?? true,
+        changeNote: data.changeNote ?? "",
+        createdByUserId: data.createdByUserId ?? null,
+        ...this.fields.validityWindows ? {
+          validFrom: data.validFrom ? new Date(data.validFrom) : null,
+          validUntil: data.validUntil ? new Date(data.validUntil) : null
+        } : {}
+      }
+    });
+    return this.toPlanVersionRow(created, planKey);
+  }
+  async updatePlanVersionDraft(versionId, data) {
+    const updated = await this.versions(this.db()).update({
+      where: {
+        id: versionId
+      },
+      data: {
+        ...data.features !== void 0 ? {
+          features: data.features
+        } : {},
+        ...data.quotas !== void 0 ? {
+          quotas: data.quotas
+        } : {},
+        ...data.monthlyNet !== void 0 ? {
+          monthlyNet: data.monthlyNet
+        } : {},
+        ...data.yearlyNet !== void 0 ? {
+          yearlyNet: data.yearlyNet
+        } : {},
+        ...data.marketed !== void 0 ? {
+          marketed: data.marketed
+        } : {},
+        ...data.changeNote !== void 0 ? {
+          changeNote: data.changeNote
+        } : {},
+        ...this.fields.validityWindows && data.validFrom !== void 0 ? {
+          validFrom: data.validFrom ? new Date(data.validFrom) : null
+        } : {},
+        ...this.fields.validityWindows && data.validUntil !== void 0 ? {
+          validUntil: data.validUntil ? new Date(data.validUntil) : null
+        } : {}
+      }
+    });
+    const planKey = await this.binding.toPlanKey(this.db(), updated.planId);
+    return this.toPlanVersionRow(updated, planKey);
+  }
+  async publishPlanVersionDraft(versionId, publishMeta, tx) {
+    const operationDb = this.db(tx);
+    const draft = await this.versions(operationDb).findUnique({
+      where: {
+        id: versionId
+      }
+    });
+    if (!draft) {
+      throw new Error(`PlanVersion ${versionId} not found.`);
+    }
+    const storedPlanId = draft.planId;
+    const publish = /* @__PURE__ */ __name(async (db) => {
+      const planVersion = this.versions(db);
+      const previous = await planVersion.findFirst({
+        where: {
+          planId: storedPlanId,
+          publishedAt: {
+            not: null
+          },
+          supersededAt: null,
+          id: {
+            not: versionId
+          }
+        },
+        orderBy: {
+          version: "desc"
+        }
+      });
+      const now = /* @__PURE__ */ new Date();
+      if (previous) {
+        const predecessorValidUntil = new Date(publishMeta.validFrom.getTime() - 24 * 60 * 60 * 1e3);
+        await planVersion.update({
+          where: {
+            id: previous.id
+          },
+          data: {
+            supersededAt: now,
+            ...this.fields.validityWindows ? {
+              validUntil: predecessorValidUntil
+            } : {}
+          }
+        });
+      }
+      return planVersion.update({
+        where: {
+          id: versionId
+        },
+        data: {
+          publishedAt: now,
+          publishedChanges: publishMeta.publishedChanges,
+          nonRegressive: publishMeta.nonRegressive,
+          publishedByUserId: publishMeta.publishedByUserId,
+          ...this.fields.validityWindows ? {
+            validFrom: publishMeta.validFrom,
+            validUntil: publishMeta.validUntil
+          } : {}
+        }
+      });
+    }, "publish");
+    const published = tx ? await publish(this.db(tx)) : await this.prisma.$transaction((txClient) => publish(txClient));
+    const planKey = await this.binding.toPlanKey(operationDb, storedPlanId);
+    return this.toPlanVersionRow(published, planKey);
+  }
+  async deletePlanVersionDraft(versionId) {
+    const planVersion = this.versions(this.db());
+    const row = await planVersion.findUnique({
+      where: {
+        id: versionId
+      }
+    });
+    if (!row) return;
+    if (row.publishedAt !== null) {
+      throw new Error(`PlanVersion ${versionId} is already published and cannot be discarded (published versions are immutable \u2014 contract protection P1).`);
+    }
+    await planVersion.deleteMany({
+      where: {
+        id: versionId,
+        publishedAt: null
+      }
+    });
+  }
+  async terminate(versionId, endsAt) {
+    if (!this.fields.endsAt) {
+      throw new Error("terminate requires schema.planVersionFields.catalog.endsAt=true and the current @saasicat/spec PlanVersion.endsAt column. Apply the additive schema before enabling SuperAdmin-initiated plan-version termination.");
+    }
+    const db = this.db();
+    const updated = await this.versions(db).update({
+      where: {
+        id: versionId
+      },
+      data: {
+        endsAt
+      }
+    });
+    const planKey = await this.binding.toPlanKey(db, updated.planId);
+    return this.toPlanVersionRow(updated, planKey);
+  }
+  toPlanVersionRow(row, planKey) {
+    return toPlanVersionRow2(row, planKey, this.fields);
+  }
+};
+PrismaPlanRepository = _ts_decorate19([
+  Injectable19(),
+  _ts_param17(0, Inject17(PRISMA_CLIENT_TOKEN)),
+  _ts_param17(1, Optional6()),
+  _ts_param17(1, Inject17(PRISMA_SCHEMA_OPTIONS_TOKEN)),
+  _ts_metadata17("design:type", Function),
+  _ts_metadata17("design:paramtypes", [
+    typeof PlanRepositoryClient === "undefined" ? Object : PlanRepositoryClient,
+    typeof PrismaSchemaOptions === "undefined" ? Object : PrismaSchemaOptions
+  ])
+], PrismaPlanRepository);
+function toPlanRow2(row) {
+  return {
+    id: row.id,
+    projectKey: row.projectKey,
+    planKey: row.planKey,
+    label: row.label,
+    description: row.description,
+    icon: row.icon,
+    sortOrder: row.sortOrder,
+    createdAt: row.createdAt.toISOString(),
+    updatedAt: row.updatedAt.toISOString(),
+    deletedAt: row.deletedAt?.toISOString() ?? null
+  };
+}
+__name(toPlanRow2, "toPlanRow");
+function toPlanVersionRow2(row, planKey, fields) {
+  const mapped = {
+    id: row.id,
+    version: row.version,
+    baseVersionId: row.baseVersionId,
+    planId: planKey,
+    features: toStringArray(row.features),
+    quotas: toQuotaMap(row.quotas),
+    monthlyNet: row.monthlyNet.toString(),
+    yearlyNet: row.yearlyNet.toString(),
+    marketed: row.marketed,
+    publishedAt: row.publishedAt?.toISOString() ?? null,
+    supersededAt: row.supersededAt?.toISOString() ?? null,
+    publishedChanges: Array.isArray(row.publishedChanges) ? row.publishedChanges : null,
+    changeNote: row.changeNote,
+    nonRegressive: row.nonRegressive,
+    validFrom: fields.validityWindows && row.validFrom ? row.validFrom.toISOString() : null,
+    validUntil: fields.validityWindows && row.validUntil ? row.validUntil.toISOString() : null,
+    createdByUserId: row.createdByUserId,
+    publishedByUserId: row.publishedByUserId,
+    createdAt: row.createdAt.toISOString(),
+    updatedAt: row.updatedAt.toISOString()
+  };
+  if (fields.endsAt) {
+    mapped.endsAt = row.endsAt?.toISOString() ?? null;
+  }
+  return mapped;
+}
+__name(toPlanVersionRow2, "toPlanVersionRow");
+
+// src/prisma-bundle.repository.ts
+import { Inject as Inject18, Injectable as Injectable20, Optional as Optional7 } from "@nestjs/common";
+import { buildActiveVersionWhere } 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_metadata18(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata18, "_ts_metadata");
+function _ts_param18(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param18, "_ts_param");
+var PRISMA_BUNDLE_REPOSITORY_OPTIONS = /* @__PURE__ */ Symbol.for("saasicat/adapter-prisma/PrismaBundleRepositoryOptions");
+var PrismaBundleRepository = class {
+  static {
+    __name(this, "PrismaBundleRepository");
+  }
+  prisma;
+  validityWindows;
+  /**
+   * Present only when validity-window mode is enabled. This mirrors the
+   * optional port capability and lets 0.6-schema consumers detect that an
+   * active-at-time lookup is unavailable.
+   */
+  findActiveBundleVersion;
+  constructor(prisma, options = {}) {
+    this.prisma = prisma;
+    this.validityWindows = options.validityWindows ?? false;
+    if (this.validityWindows) {
+      this.findActiveBundleVersion = (bundleId, asOf, tx) => this.findActiveBundleVersionWithValidity(bundleId, asOf ?? /* @__PURE__ */ new Date(), tx);
+    }
+  }
+  db(tx) {
+    return tx ?? this.prisma;
+  }
+  transaction(work) {
+    const transaction = this.prisma.$transaction;
+    return transaction.call(this.prisma, (tx) => work(tx));
+  }
+  // ─── Stem operations ───
+  async list(filter) {
+    const excludeDeleted = filter.excludeDeleted ?? true;
+    const rows = await this.db().bundle.findMany({
+      where: {
+        projectKey: filter.projectKey,
+        ...excludeDeleted ? {
+          deletedAt: null
+        } : {}
+      },
+      orderBy: [
+        {
+          sortOrder: "asc"
+        },
+        {
+          bundleKey: "asc"
+        }
+      ]
+    });
+    return rows.map(toBundleRow);
+  }
+  async findById(bundleId) {
+    const row = await this.db().bundle.findUnique({
+      where: {
+        id: bundleId
+      }
+    });
+    return row ? toBundleRow(row) : null;
+  }
+  async findByKey(projectKey, bundleKey) {
+    const row = await this.db().bundle.findFirst({
+      where: {
+        projectKey,
+        bundleKey,
+        deletedAt: null
+      }
+    });
+    return row ? toBundleRow(row) : null;
+  }
+  async create(data) {
+    const created = await this.db().bundle.create({
+      data: {
+        projectKey: data.projectKey,
+        bundleKey: data.bundleKey,
+        label: data.label,
+        description: data.description ?? null,
+        icon: data.icon ?? null,
+        sortOrder: data.sortOrder ?? 0,
+        i18n: data.i18n ?? {}
+      }
+    });
+    return toBundleRow(created);
+  }
+  async update(bundleId, data) {
+    const updated = await this.db().bundle.update({
+      where: {
+        id: bundleId
+      },
+      data: {
+        ...data.label !== void 0 ? {
+          label: data.label
+        } : {},
+        ...data.description !== void 0 ? {
+          description: data.description
+        } : {},
+        ...data.icon !== void 0 ? {
+          icon: data.icon
+        } : {},
+        ...data.sortOrder !== void 0 ? {
+          sortOrder: data.sortOrder
+        } : {},
+        ...data.i18n !== void 0 ? {
+          i18n: data.i18n
+        } : {}
+      }
+    });
+    return toBundleRow(updated);
+  }
+  async softDelete(bundleId) {
+    await this.db().bundle.update({
+      where: {
+        id: bundleId
+      },
+      data: {
+        deletedAt: /* @__PURE__ */ new Date()
+      }
+    });
+  }
+  // ─── Version operations ───
+  async listVersions(bundleId) {
+    const bundle = await this.db().bundle.findUnique({
+      where: {
+        id: bundleId
+      }
+    });
+    if (!bundle) return [];
+    const rows = await this.db().bundleVersion.findMany({
+      where: {
+        bundleId
+      },
+      orderBy: {
+        version: "asc"
+      }
+    });
+    return rows.map((row) => toBundleVersionRow(row, bundle, this.validityWindows));
+  }
+  async findVersionById(versionId) {
+    const row = await this.db().bundleVersion.findUnique({
+      where: {
+        id: versionId
+      }
+    });
+    if (!row) return null;
+    const bundle = await this.db().bundle.findUnique({
+      where: {
+        id: row.bundleId
+      }
+    });
+    return toBundleVersionRow(row, bundle, this.validityWindows);
+  }
+  async findCurrentDraft(bundleId) {
+    const row = await this.db().bundleVersion.findFirst({
+      where: {
+        bundleId,
+        publishedAt: null
+      }
+    });
+    if (!row) return null;
+    const bundle = await this.db().bundle.findUnique({
+      where: {
+        id: bundleId
+      }
+    });
+    return toBundleVersionRow(row, bundle, this.validityWindows);
+  }
+  async findLatestLive(bundleId, tx) {
+    const db = this.db(tx);
+    const row = await db.bundleVersion.findFirst({
+      where: {
+        bundleId,
+        publishedAt: {
+          not: null
+        },
+        supersededAt: null
+      },
+      orderBy: {
+        version: "desc"
+      }
+    });
+    if (!row) return null;
+    const bundle = await db.bundle.findUnique({
+      where: {
+        id: bundleId
+      }
+    });
+    return toBundleVersionRow(row, bundle, this.validityWindows);
+  }
+  async findActiveBundleVersionWithValidity(bundleId, asOf, tx) {
+    const db = this.db(tx);
+    const row = await db.bundleVersion.findFirst({
+      where: {
+        bundleId,
+        ...buildActiveVersionWhere(asOf)
+      },
+      orderBy: [
+        {
+          validFrom: {
+            sort: "desc",
+            nulls: "last"
+          }
+        },
+        {
+          version: "desc"
+        }
+      ]
+    });
+    if (!row) return null;
+    const bundle = await db.bundle.findUnique({
+      where: {
+        id: bundleId
+      }
+    });
+    return toBundleVersionRow(row, bundle, true);
+  }
+  async createDraft(data) {
+    const db = this.db();
+    const existingDraft = await db.bundleVersion.findFirst({
+      where: {
+        bundleId: data.bundleId,
+        publishedAt: null
+      }
+    });
+    if (existingDraft) {
+      throw new Error(`Bundle '${data.bundleId}' already has a draft version (v${existingDraft.version}); only one draft per bundle is allowed.`);
+    }
+    const latest = await db.bundleVersion.findFirst({
+      where: {
+        bundleId: data.bundleId
+      },
+      orderBy: {
+        version: "desc"
+      }
+    });
+    const nextVersion = latest ? latest.version + 1 : 1;
+    const created = await db.bundleVersion.create({
+      data: {
+        bundleId: data.bundleId,
+        version: nextVersion,
+        baseVersionId: data.baseVersionId ?? null,
+        features: data.features,
+        quotas: data.quotas ?? {},
+        compatibility: data.compatibility ?? {},
+        pricingOverrides: data.pricingOverrides ?? [],
+        monthlyNet: data.monthlyNet ?? null,
+        yearlyNet: data.yearlyNet ?? null,
+        marketed: data.marketed ?? true,
+        changeNote: data.changeNote ?? "",
+        createdByUserId: data.createdByUserId ?? null,
+        ...this.validityWindows ? {
+          validFrom: toNullableDate(data.validFrom),
+          validUntil: toNullableDate(data.validUntil)
+        } : {}
+      }
+    });
+    const bundle = await db.bundle.findUnique({
+      where: {
+        id: data.bundleId
+      }
+    });
+    return toBundleVersionRow(created, bundle, this.validityWindows);
+  }
+  async updateDraft(versionId, data) {
+    const db = this.db();
+    const updated = await db.bundleVersion.update({
+      where: {
+        id: versionId
+      },
+      data: {
+        ...data.features !== void 0 ? {
+          features: data.features
+        } : {},
+        ...data.quotas !== void 0 ? {
+          quotas: data.quotas
+        } : {},
+        ...data.compatibility !== void 0 ? {
+          compatibility: data.compatibility
+        } : {},
+        ...data.pricingOverrides !== void 0 ? {
+          pricingOverrides: data.pricingOverrides
+        } : {},
+        ...data.monthlyNet !== void 0 ? {
+          monthlyNet: data.monthlyNet
+        } : {},
+        ...data.yearlyNet !== void 0 ? {
+          yearlyNet: data.yearlyNet
+        } : {},
+        ...data.marketed !== void 0 ? {
+          marketed: data.marketed
+        } : {},
+        ...data.changeNote !== void 0 ? {
+          changeNote: data.changeNote
+        } : {},
+        ...this.validityWindows && data.validFrom !== void 0 ? {
+          validFrom: toNullableDate(data.validFrom)
+        } : {},
+        ...this.validityWindows && data.validUntil !== void 0 ? {
+          validUntil: toNullableDate(data.validUntil)
+        } : {}
+      }
+    });
+    const bundle = await db.bundle.findUnique({
+      where: {
+        id: updated.bundleId
+      }
+    });
+    return toBundleVersionRow(updated, bundle, this.validityWindows);
+  }
+  async publishDraft(versionId, publishMeta, tx) {
+    if (this.validityWindows && tx === void 0) {
+      return this.transaction((transaction) => this.publishDraftWithValidity(transaction, versionId, publishMeta));
+    }
+    if (this.validityWindows) {
+      return this.publishDraftWithValidity(this.db(tx), versionId, publishMeta);
+    }
+    const db = this.db(tx);
+    const draft = await db.bundleVersion.findUnique({
+      where: {
+        id: versionId
+      }
+    });
+    if (!draft) {
+      throw new Error(`BundleVersion '${versionId}' not found.`);
+    }
+    await db.bundleVersion.updateMany({
+      where: {
+        bundleId: draft.bundleId,
+        publishedAt: {
+          not: null
+        },
+        supersededAt: null,
+        NOT: {
+          id: versionId
+        }
+      },
+      data: {
+        supersededAt: /* @__PURE__ */ new Date()
+      }
+    });
+    const published = await db.bundleVersion.update({
+      where: {
+        id: versionId
+      },
+      data: {
+        publishedAt: /* @__PURE__ */ new Date(),
+        publishedByUserId: publishMeta.publishedByUserId,
+        publishedChanges: publishMeta.publishedChanges,
+        nonRegressive: publishMeta.nonRegressive
+      }
+    });
+    const bundle = await db.bundle.findUnique({
+      where: {
+        id: published.bundleId
+      }
+    });
+    return toBundleVersionRow(published, bundle, false);
+  }
+  async publishDraftWithValidity(db, versionId, publishMeta) {
+    const draft = await db.bundleVersion.findUnique({
+      where: {
+        id: versionId
+      }
+    });
+    if (!draft) {
+      throw new Error(`BundleVersion '${versionId}' not found.`);
+    }
+    const now = /* @__PURE__ */ new Date();
+    await db.bundleVersion.updateMany({
+      where: {
+        bundleId: draft.bundleId,
+        publishedAt: {
+          not: null
+        },
+        supersededAt: null,
+        NOT: {
+          id: versionId
+        }
+      },
+      data: {
+        supersededAt: now,
+        validUntil: previousUtcDay(publishMeta.validFrom)
+      }
+    });
+    const published = await db.bundleVersion.update({
+      where: {
+        id: versionId
+      },
+      data: {
+        publishedAt: now,
+        publishedByUserId: publishMeta.publishedByUserId,
+        publishedChanges: publishMeta.publishedChanges,
+        nonRegressive: publishMeta.nonRegressive,
+        validFrom: publishMeta.validFrom,
+        validUntil: publishMeta.validUntil
+      }
+    });
+    const bundle = await db.bundle.findUnique({
+      where: {
+        id: published.bundleId
+      }
+    });
+    return toBundleVersionRow(published, bundle, true);
+  }
+  async deleteDraft(versionId) {
+    const db = this.db();
+    const row = await db.bundleVersion.findUnique({
+      where: {
+        id: versionId
+      }
+    });
+    if (!row) return;
+    if (row.publishedAt !== null) {
+      throw new Error(`BundleVersion '${versionId}' is already published and cannot be discarded (published versions are immutable \u2014 contract protection P1).`);
+    }
+    try {
+      await db.bundleVersion.delete({
+        where: {
+          id: versionId
+        }
+      });
+    } catch (err) {
+      if (err?.code === "P2025") return;
+      throw err;
+    }
+  }
+};
+PrismaBundleRepository = _ts_decorate20([
+  Injectable20(),
+  _ts_param18(0, Inject18(PRISMA_CLIENT_TOKEN)),
+  _ts_param18(1, Optional7()),
+  _ts_param18(1, Inject18(PRISMA_BUNDLE_REPOSITORY_OPTIONS)),
+  _ts_metadata18("design:type", Function),
+  _ts_metadata18("design:paramtypes", [
+    typeof BundlePrismaClient === "undefined" ? Object : BundlePrismaClient,
+    typeof PrismaBundleRepositoryOptions === "undefined" ? Object : PrismaBundleRepositoryOptions
+  ])
+], PrismaBundleRepository);
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+__name(isPlainObject, "isPlainObject");
+function toDecimalString(value) {
+  return value == null ? null : value.toString();
+}
+__name(toDecimalString, "toDecimalString");
+function toNullableDate(value) {
+  return value ? new Date(value) : null;
+}
+__name(toNullableDate, "toNullableDate");
+function previousUtcDay(value) {
+  const result = new Date(value);
+  result.setUTCDate(result.getUTCDate() - 1);
+  return result;
+}
+__name(previousUtcDay, "previousUtcDay");
+function toVersionChanges(value) {
+  return Array.isArray(value) ? value : null;
+}
+__name(toVersionChanges, "toVersionChanges");
+function toCompatibility(value) {
+  return isPlainObject(value) ? value : {};
+}
+__name(toCompatibility, "toCompatibility");
+function toPricingOverrides(value) {
+  return Array.isArray(value) ? value : [];
+}
+__name(toPricingOverrides, "toPricingOverrides");
+function toI18n(value) {
+  return isPlainObject(value) ? value : {};
+}
+__name(toI18n, "toI18n");
+function toBundleRow(row) {
+  return {
+    id: row.id,
+    projectKey: row.projectKey,
+    bundleKey: row.bundleKey,
+    label: row.label,
+    description: row.description,
+    icon: row.icon,
+    sortOrder: row.sortOrder,
+    i18n: toI18n(row.i18n),
+    createdAt: row.createdAt.toISOString(),
+    updatedAt: row.updatedAt.toISOString(),
+    deletedAt: row.deletedAt?.toISOString() ?? null
+  };
+}
+__name(toBundleRow, "toBundleRow");
+function toBundleVersionRow(row, bundle, validityWindows) {
+  return {
+    id: row.id,
+    bundleId: row.bundleId,
+    bundleKey: bundle?.bundleKey ?? "",
+    label: bundle?.label ?? "",
+    version: row.version,
+    baseVersionId: row.baseVersionId,
+    features: toStringArray(row.features),
+    quotas: toQuotaMap(row.quotas),
+    compatibility: toCompatibility(row.compatibility),
+    pricingOverrides: toPricingOverrides(row.pricingOverrides),
+    monthlyNet: toDecimalString(row.monthlyNet),
+    yearlyNet: toDecimalString(row.yearlyNet),
+    marketed: row.marketed,
+    publishedAt: row.publishedAt?.toISOString() ?? null,
+    supersededAt: row.supersededAt?.toISOString() ?? null,
+    validFrom: validityWindows && row.validFrom instanceof Date ? row.validFrom.toISOString() : null,
+    validUntil: validityWindows && row.validUntil instanceof Date ? row.validUntil.toISOString() : null,
+    publishedChanges: toVersionChanges(row.publishedChanges),
+    changeNote: row.changeNote,
+    nonRegressive: row.nonRegressive,
+    createdByUserId: row.createdByUserId,
+    publishedByUserId: row.publishedByUserId,
+    createdAt: row.createdAt.toISOString(),
+    updatedAt: row.updatedAt.toISOString()
+  };
+}
+__name(toBundleVersionRow, "toBundleVersionRow");
+
+// src/prisma-catalog-entry.repository.ts
+import { Inject as Inject19, Injectable as Injectable21 } from "@nestjs/common";
+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_metadata19(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata19, "_ts_metadata");
+function _ts_param19(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param19, "_ts_param");
+var PrismaCatalogEntryRepository = class {
+  static {
+    __name(this, "PrismaCatalogEntryRepository");
+  }
+  prisma;
+  constructor(prisma) {
+    this.prisma = prisma;
+  }
+  get db() {
+    return this.prisma;
+  }
+  async listCapabilities(filter) {
+    const rows = await this.db.capabilityCatalogEntry.findMany({
+      where: {
+        projectKey: filter.projectKey,
+        deletedAt: null,
+        ...filter.codeStatus ? {
+          codeStatus: filter.codeStatus
+        } : {}
+      },
+      orderBy: [
+        {
+          sortOrder: "asc"
+        },
+        {
+          capabilityKey: "asc"
+        }
+      ]
+    });
+    return rows.map(toCapabilityRow);
+  }
+  async listFeatures(filter) {
+    const rows = await this.db.featureCatalogEntry.findMany({
+      where: {
+        projectKey: filter.projectKey,
+        deletedAt: null,
+        ...filter.discoveryStatus ? {
+          discoveryStatus: filter.discoveryStatus
+        } : {}
+      },
+      orderBy: [
+        {
+          sortOrder: "asc"
+        },
+        {
+          featureKey: "asc"
+        }
+      ]
+    });
+    return rows.map(toFeatureRow);
+  }
+  async listQuotas(filter) {
+    const rows = await this.db.quotaCatalogEntry.findMany({
+      where: {
+        projectKey: filter.projectKey,
+        deletedAt: null,
+        ...filter.discoveryStatus ? {
+          discoveryStatus: filter.discoveryStatus
+        } : {}
+      },
+      orderBy: [
+        {
+          sortOrder: "asc"
+        },
+        {
+          quotaKey: "asc"
+        }
+      ]
+    });
+    return rows.map(toQuotaRow);
+  }
+  async upsertCapability(data) {
+    const codeFields = {
+      label: data.label,
+      description: data.description,
+      featureKey: data.featureKey,
+      bundleKey: data.bundleKey,
+      codeStatus: data.codeStatus,
+      owner: data.owner,
+      kind: data.kind,
+      replacementKey: data.replacementKey,
+      deprecatedAt: data.deprecatedAt ? new Date(data.deprecatedAt) : null,
+      removalPlannedAt: data.removalPlannedAt ? new Date(data.removalPlannedAt) : null,
+      reason: data.reason
+    };
+    const row = await this.db.capabilityCatalogEntry.upsert({
+      where: {
+        projectKey_capabilityKey: {
+          projectKey: data.projectKey,
+          capabilityKey: data.capabilityKey
+        }
+      },
+      create: {
+        projectKey: data.projectKey,
+        capabilityKey: data.capabilityKey,
+        ...codeFields
+      },
+      update: codeFields
+    });
+    return toCapabilityRow(row);
+  }
+  async upsertFeature(data) {
+    const codeFields = {
+      label: data.label,
+      description: data.description,
+      discoveryStatus: data.discoveryStatus,
+      requires: data.requires,
+      replaces: data.replaces,
+      ...data.core !== void 0 ? {
+        core: data.core
+      } : {}
+    };
+    const row = await this.db.featureCatalogEntry.upsert({
+      where: {
+        projectKey_featureKey: {
+          projectKey: data.projectKey,
+          featureKey: data.featureKey
+        }
+      },
+      create: {
+        projectKey: data.projectKey,
+        featureKey: data.featureKey,
+        ...codeFields
+      },
+      update: codeFields
+    });
+    return toFeatureRow(row);
+  }
+  async upsertQuota(data) {
+    const codeFields = {
+      label: data.label,
+      description: data.description,
+      unit: data.unit,
+      featureKey: data.featureKey,
+      usageProvider: data.usageProvider,
+      enforcementMode: data.enforcementMode,
+      discoveryStatus: data.discoveryStatus,
+      replaces: data.replaces
+    };
+    const row = await this.db.quotaCatalogEntry.upsert({
+      where: {
+        projectKey_quotaKey: {
+          projectKey: data.projectKey,
+          quotaKey: data.quotaKey
+        }
+      },
+      create: {
+        projectKey: data.projectKey,
+        quotaKey: data.quotaKey,
+        ...codeFields
+      },
+      update: codeFields
+    });
+    return toQuotaRow(row);
+  }
+  async retireMissing(projectKey, type, presentKeys) {
+    if (type === "capability") {
+      const res2 = await this.db.capabilityCatalogEntry.updateMany({
+        where: {
+          projectKey,
+          deletedAt: null,
+          codeStatus: {
+            not: "retired"
+          },
+          capabilityKey: {
+            notIn: presentKeys
+          }
+        },
+        data: {
+          codeStatus: "retired"
+        }
+      });
+      return res2.count;
+    }
+    if (type === "feature") {
+      const res2 = await this.db.featureCatalogEntry.updateMany({
+        where: {
+          projectKey,
+          deletedAt: null,
+          discoveryStatus: {
+            not: "obsolete"
+          },
+          featureKey: {
+            notIn: presentKeys
+          }
+        },
+        data: {
+          discoveryStatus: "obsolete"
+        }
+      });
+      return res2.count;
+    }
+    const res = await this.db.quotaCatalogEntry.updateMany({
+      where: {
+        projectKey,
+        deletedAt: null,
+        discoveryStatus: {
+          not: "obsolete"
+        },
+        quotaKey: {
+          notIn: presentKeys
+        }
+      },
+      data: {
+        discoveryStatus: "obsolete"
+      }
+    });
+    return res.count;
+  }
+  async setFeatureSuccessor(projectKey, featureKey, successorKey) {
+    const row = await this.db.featureCatalogEntry.update({
+      where: {
+        projectKey_featureKey: {
+          projectKey,
+          featureKey
+        }
+      },
+      data: {
+        successorKey
+      }
+    });
+    return toFeatureRow(row);
+  }
+  async setQuotaSuccessor(projectKey, quotaKey, successorKey) {
+    const row = await this.db.quotaCatalogEntry.update({
+      where: {
+        projectKey_quotaKey: {
+          projectKey,
+          quotaKey
+        }
+      },
+      data: {
+        successorKey
+      }
+    });
+    return toQuotaRow(row);
+  }
+  async findFeature(projectKey, featureKey) {
+    const row = await this.db.featureCatalogEntry.findUnique({
+      where: {
+        projectKey_featureKey: {
+          projectKey,
+          featureKey
+        }
+      }
+    });
+    return row ? toFeatureRow(row) : null;
+  }
+  async findQuota(projectKey, quotaKey) {
+    const row = await this.db.quotaCatalogEntry.findUnique({
+      where: {
+        projectKey_quotaKey: {
+          projectKey,
+          quotaKey
+        }
+      }
+    });
+    return row ? toQuotaRow(row) : null;
+  }
+  async setFeatureReview(projectKey, featureKey, data) {
+    const row = await this.db.featureCatalogEntry.update({
+      where: {
+        projectKey_featureKey: {
+          projectKey,
+          featureKey
+        }
+      },
+      data: {
+        discoveryStatus: data.discoveryStatus,
+        approvedAt: data.approvedAt ? new Date(data.approvedAt) : null,
+        approvedBy: data.approvedBy,
+        approvedSignature: data.approvedSignature
+      }
+    });
+    return toFeatureRow(row);
+  }
+  async setQuotaReview(projectKey, quotaKey, data) {
+    const row = await this.db.quotaCatalogEntry.update({
+      where: {
+        projectKey_quotaKey: {
+          projectKey,
+          quotaKey
+        }
+      },
+      data: {
+        discoveryStatus: data.discoveryStatus,
+        approvedAt: data.approvedAt ? new Date(data.approvedAt) : null,
+        approvedBy: data.approvedBy,
+        approvedSignature: data.approvedSignature
+      }
+    });
+    return toQuotaRow(row);
+  }
+  async setFeatureI18n(projectKey, featureKey, i18n) {
+    const row = await this.db.featureCatalogEntry.update({
+      where: {
+        projectKey_featureKey: {
+          projectKey,
+          featureKey
+        }
+      },
+      data: {
+        i18n
+      }
+    });
+    return toFeatureRow(row);
+  }
+  async setQuotaI18n(projectKey, quotaKey, i18n) {
+    const row = await this.db.quotaCatalogEntry.update({
+      where: {
+        projectKey_quotaKey: {
+          projectKey,
+          quotaKey
+        }
+      },
+      data: {
+        i18n
+      }
+    });
+    return toQuotaRow(row);
+  }
+  async setFeatureBase(projectKey, featureKey, data) {
+    const row = await this.db.featureCatalogEntry.update({
+      where: {
+        projectKey_featureKey: {
+          projectKey,
+          featureKey
+        }
+      },
+      data: {
+        ...data.label !== void 0 ? {
+          label: data.label
+        } : {},
+        ...data.description !== void 0 ? {
+          description: data.description
+        } : {},
+        ...data.icon !== void 0 ? {
+          icon: data.icon
+        } : {},
+        ...data.tier !== void 0 ? {
+          tier: data.tier
+        } : {}
+      }
+    });
+    return toFeatureRow(row);
+  }
+  async setQuotaBase(projectKey, quotaKey, data) {
+    const row = await this.db.quotaCatalogEntry.update({
+      where: {
+        projectKey_quotaKey: {
+          projectKey,
+          quotaKey
+        }
+      },
+      data: {
+        ...data.label !== void 0 ? {
+          label: data.label
+        } : {},
+        ...data.description !== void 0 ? {
+          description: data.description
+        } : {}
+      }
+    });
+    return toQuotaRow(row);
+  }
+};
+PrismaCatalogEntryRepository = _ts_decorate21([
+  Injectable21(),
+  _ts_param19(0, Inject19(PRISMA_CLIENT_TOKEN)),
+  _ts_metadata19("design:type", Function),
+  _ts_metadata19("design:paramtypes", [
+    typeof CatalogEntryRepositoryClient === "undefined" ? Object : CatalogEntryRepositoryClient
+  ])
+], PrismaCatalogEntryRepository);
+function toI18n2(value) {
+  if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+    return value;
+  }
+  return {};
+}
+__name(toI18n2, "toI18n");
+function toCapabilityRow(row) {
+  return {
+    id: row.id,
+    projectKey: row.projectKey,
+    capabilityKey: row.capabilityKey,
+    label: row.label,
+    description: row.description,
+    featureKey: row.featureKey,
+    bundleKey: row.bundleKey,
+    codeStatus: row.codeStatus,
+    owner: row.owner,
+    kind: row.kind,
+    replacementKey: row.replacementKey,
+    deprecatedAt: row.deprecatedAt ? row.deprecatedAt.toISOString() : null,
+    removalPlannedAt: row.removalPlannedAt ? row.removalPlannedAt.toISOString() : null,
+    reason: row.reason,
+    i18n: toI18n2(row.i18n),
+    sortOrder: row.sortOrder,
+    createdAt: row.createdAt.toISOString(),
+    updatedAt: row.updatedAt.toISOString(),
+    deletedAt: row.deletedAt ? row.deletedAt.toISOString() : null
+  };
+}
+__name(toCapabilityRow, "toCapabilityRow");
+function toFeatureRow(row) {
+  return {
+    id: row.id,
+    projectKey: row.projectKey,
+    featureKey: row.featureKey,
+    label: row.label,
+    description: row.description,
+    marketingLabel: row.marketingLabel,
+    marketingDescription: row.marketingDescription,
+    icon: row.icon,
+    tier: row.tier,
+    discoveryStatus: row.discoveryStatus,
+    requires: row.requires,
+    replaces: row.replaces,
+    successorKey: row.successorKey,
+    approvedAt: row.approvedAt ? row.approvedAt.toISOString() : null,
+    approvedBy: row.approvedBy,
+    approvedSignature: row.approvedSignature,
+    plannedOnly: row.plannedOnly,
+    core: row.core,
+    i18n: toI18n2(row.i18n),
+    sortOrder: row.sortOrder,
+    createdAt: row.createdAt.toISOString(),
+    updatedAt: row.updatedAt.toISOString(),
+    deletedAt: row.deletedAt ? row.deletedAt.toISOString() : null
+  };
+}
+__name(toFeatureRow, "toFeatureRow");
+function toQuotaRow(row) {
+  return {
+    id: row.id,
+    projectKey: row.projectKey,
+    quotaKey: row.quotaKey,
+    label: row.label,
+    description: row.description,
+    unit: row.unit,
+    featureKey: row.featureKey,
+    usageProvider: row.usageProvider,
+    enforcementMode: row.enforcementMode,
+    discoveryStatus: row.discoveryStatus,
+    replaces: row.replaces,
+    successorKey: row.successorKey,
+    approvedAt: row.approvedAt ? row.approvedAt.toISOString() : null,
+    approvedBy: row.approvedBy,
+    approvedSignature: row.approvedSignature,
+    i18n: toI18n2(row.i18n),
+    sortOrder: row.sortOrder,
+    createdAt: row.createdAt.toISOString(),
+    updatedAt: row.updatedAt.toISOString(),
+    deletedAt: row.deletedAt ? row.deletedAt.toISOString() : null
+  };
+}
+__name(toQuotaRow, "toQuotaRow");
+
+// src/prisma-marketing-projection.repository.ts
+import { Inject as Inject20, Injectable as Injectable22 } from "@nestjs/common";
+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_metadata20(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata20, "_ts_metadata");
+function _ts_param20(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param20, "_ts_param");
+var PrismaMarketingProjectionRepository = class {
+  static {
+    __name(this, "PrismaMarketingProjectionRepository");
+  }
+  prisma;
+  constructor(prisma) {
+    this.prisma = prisma;
+  }
+  get db() {
+    return this.prisma;
+  }
+  async list(filter) {
+    const rows = await this.db.marketingProjection.findMany({
+      where: {
+        projectKey: filter.projectKey,
+        ...filter.targetType ? {
+          targetType: filter.targetType
+        } : {},
+        ...filter.targetVersionId ? {
+          targetVersionId: filter.targetVersionId
+        } : {},
+        ...filter.locale ? {
+          locale: filter.locale
+        } : {}
+      },
+      orderBy: [
+        {
+          priority: "desc"
+        },
+        {
+          displayLabel: "asc"
+        }
+      ]
+    });
+    return rows.map(toRow);
+  }
+  async findById(id) {
+    const row = await this.db.marketingProjection.findUnique({
+      where: {
+        id
+      }
+    });
+    return row ? toRow(row) : null;
+  }
+  async findByTarget(targetType, targetVersionId, locale) {
+    const row = await this.db.marketingProjection.findUnique({
+      where: {
+        targetType_targetVersionId_locale: {
+          targetType,
+          targetVersionId,
+          locale
+        }
+      }
+    });
+    return row ? toRow(row) : null;
+  }
+  async create(data) {
+    const row = await this.db.marketingProjection.create({
+      data: {
+        projectKey: data.projectKey,
+        targetType: data.targetType,
+        targetVersionId: data.targetVersionId,
+        locale: data.locale ?? "de",
+        displayLabel: data.displayLabel,
+        description: data.description,
+        visible: data.visible ?? true,
+        badge: data.badge ?? "",
+        topFeatures: data.topFeatures ?? [],
+        trialEnabled: data.trialEnabled ?? false,
+        trialDays: data.trialDays ?? 30,
+        priceTag: data.priceTag ?? null,
+        ctaLabel: data.ctaLabel ?? null,
+        priority: data.priority ?? 0,
+        highlight: data.highlight ?? false
+      }
+    });
+    return toRow(row);
+  }
+  async update(id, data) {
+    const row = await this.db.marketingProjection.update({
+      where: {
+        id
+      },
+      data: {
+        ...data.displayLabel !== void 0 ? {
+          displayLabel: data.displayLabel
+        } : {},
+        ...data.description !== void 0 ? {
+          description: data.description
+        } : {},
+        ...data.visible !== void 0 ? {
+          visible: data.visible
+        } : {},
+        ...data.badge !== void 0 ? {
+          badge: data.badge
+        } : {},
+        ...data.topFeatures !== void 0 ? {
+          topFeatures: data.topFeatures
+        } : {},
+        ...data.trialEnabled !== void 0 ? {
+          trialEnabled: data.trialEnabled
+        } : {},
+        ...data.trialDays !== void 0 ? {
+          trialDays: data.trialDays
+        } : {},
+        ...data.priceTag !== void 0 ? {
+          priceTag: data.priceTag
+        } : {},
+        ...data.ctaLabel !== void 0 ? {
+          ctaLabel: data.ctaLabel
+        } : {},
+        ...data.priority !== void 0 ? {
+          priority: data.priority
+        } : {},
+        ...data.highlight !== void 0 ? {
+          highlight: data.highlight
+        } : {}
+      }
+    });
+    return toRow(row);
+  }
+  async delete(id) {
+    await this.db.marketingProjection.delete({
+      where: {
+        id
+      }
+    });
+  }
+};
+PrismaMarketingProjectionRepository = _ts_decorate22([
+  Injectable22(),
+  _ts_param20(0, Inject20(PRISMA_CLIENT_TOKEN)),
+  _ts_metadata20("design:type", Function),
+  _ts_metadata20("design:paramtypes", [
+    typeof MarketingProjectionRepositoryClient === "undefined" ? Object : MarketingProjectionRepositoryClient
+  ])
+], PrismaMarketingProjectionRepository);
+function toTopFeatures(value) {
+  return Array.isArray(value) ? value : [];
+}
+__name(toTopFeatures, "toTopFeatures");
+function toRow(row) {
+  return {
+    id: row.id,
+    projectKey: row.projectKey,
+    targetType: row.targetType,
+    targetVersionId: row.targetVersionId,
+    locale: row.locale,
+    displayLabel: row.displayLabel,
+    description: row.description,
+    visible: row.visible,
+    badge: row.badge,
+    topFeatures: toTopFeatures(row.topFeatures),
+    trialEnabled: row.trialEnabled,
+    trialDays: row.trialDays,
+    priceTag: row.priceTag,
+    ctaLabel: row.ctaLabel,
+    priority: row.priority,
+    highlight: row.highlight,
+    createdAt: row.createdAt.toISOString(),
+    updatedAt: row.updatedAt.toISOString()
+  };
+}
+__name(toRow, "toRow");
+
+// src/prisma-marketing-settings.repository.ts
+import { Inject as Inject21, Injectable as Injectable23 } from "@nestjs/common";
+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");
+function _ts_metadata21(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata21, "_ts_metadata");
+function _ts_param21(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param21, "_ts_param");
+var PrismaMarketingSettingsRepository = class {
+  static {
+    __name(this, "PrismaMarketingSettingsRepository");
+  }
+  prisma;
+  constructor(prisma) {
+    this.prisma = prisma;
+  }
+  get db() {
+    return this.prisma;
+  }
+  async get(projectKey) {
+    const row = await this.db.marketingSettings.findUnique({
+      where: {
+        projectKey
+      }
+    });
+    return row ? toRow2(row) : null;
+  }
+  async upsert(projectKey, data) {
+    const row = await this.db.marketingSettings.upsert({
+      where: {
+        projectKey
+      },
+      create: {
+        projectKey,
+        activeLocales: data.activeLocales
+      },
+      update: {
+        activeLocales: data.activeLocales
+      }
+    });
+    return toRow2(row);
+  }
+};
+PrismaMarketingSettingsRepository = _ts_decorate23([
+  Injectable23(),
+  _ts_param21(0, Inject21(PRISMA_CLIENT_TOKEN)),
+  _ts_metadata21("design:type", Function),
+  _ts_metadata21("design:paramtypes", [
+    typeof MarketingSettingsRepositoryClient === "undefined" ? Object : MarketingSettingsRepositoryClient
+  ])
+], PrismaMarketingSettingsRepository);
+function toRow2(row) {
+  return {
+    projectKey: row.projectKey,
+    activeLocales: toStringArray(row.activeLocales),
+    updatedAt: row.updatedAt.toISOString()
+  };
+}
+__name(toRow2, "toRow");
+
+// src/prisma-promotion.repository.ts
+import { Inject as Inject22, Injectable as Injectable24 } from "@nestjs/common";
+function _ts_decorate24(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_decorate24, "_ts_decorate");
+function _ts_metadata22(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata22, "_ts_metadata");
+function _ts_param22(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param22, "_ts_param");
+var PrismaPromotionRepository = class {
+  static {
+    __name(this, "PrismaPromotionRepository");
+  }
+  prisma;
+  constructor(prisma) {
+    this.prisma = prisma;
+  }
+  get db() {
+    return this.prisma;
+  }
+  async list(filter) {
+    const rows = await this.db.promotion.findMany({
+      where: {
+        projectKey: filter.projectKey
+      },
+      orderBy: [
+        {
+          validFrom: "desc"
+        }
+      ]
+    });
+    return rows.map(toRow3);
+  }
+  async findById(id) {
+    const row = await this.db.promotion.findUnique({
+      where: {
+        id
+      }
+    });
+    return row ? toRow3(row) : null;
+  }
+  async create(data) {
+    const row = await this.db.promotion.create({
+      data: {
+        projectKey: data.projectKey,
+        internalLabel: data.internalLabel,
+        type: data.type,
+        value: data.value,
+        targetType: data.targetType ?? "PLAN",
+        appliesTo: data.appliesTo ?? [],
+        billingCycle: data.billingCycle ?? "both",
+        validFrom: new Date(data.validFrom),
+        validTo: new Date(data.validTo),
+        priority: data.priority ?? 0,
+        requiresCoupon: data.requiresCoupon ?? false,
+        codes: data.codes ?? [],
+        color: data.color ?? "#2563eb",
+        i18n: data.i18n ?? {},
+        // Null/undefined restriction is left off so the nullable column
+        // stays SQL NULL (= all locales).
+        ...Array.isArray(data.onlyLocales) ? {
+          onlyLocales: data.onlyLocales
+        } : {}
+      }
+    });
+    return toRow3(row);
+  }
+  async update(id, data) {
+    if (data.onlyLocales === null) {
+      const executeRaw = this.prisma.$executeRaw.bind(this.prisma);
+      await executeRaw`
+                UPDATE promotions SET "onlyLocales" = NULL, "updatedAt" = NOW() WHERE id = ${id}`;
+    }
+    const row = await this.db.promotion.update({
+      where: {
+        id
+      },
+      data: {
+        ...data.internalLabel !== void 0 ? {
+          internalLabel: data.internalLabel
+        } : {},
+        ...data.type !== void 0 ? {
+          type: data.type
+        } : {},
+        ...data.value !== void 0 ? {
+          value: data.value
+        } : {},
+        ...data.appliesTo !== void 0 ? {
+          appliesTo: data.appliesTo
+        } : {},
+        ...data.targetType !== void 0 ? {
+          targetType: data.targetType
+        } : {},
+        ...data.billingCycle !== void 0 ? {
+          billingCycle: data.billingCycle
+        } : {},
+        ...data.validFrom !== void 0 ? {
+          validFrom: new Date(data.validFrom)
+        } : {},
+        ...data.validTo !== void 0 ? {
+          validTo: new Date(data.validTo)
+        } : {},
+        ...data.priority !== void 0 ? {
+          priority: data.priority
+        } : {},
+        ...data.requiresCoupon !== void 0 ? {
+          requiresCoupon: data.requiresCoupon
+        } : {},
+        ...data.codes !== void 0 ? {
+          codes: data.codes
+        } : {},
+        ...data.color !== void 0 ? {
+          color: data.color
+        } : {},
+        ...data.i18n !== void 0 ? {
+          i18n: data.i18n
+        } : {},
+        ...Array.isArray(data.onlyLocales) ? {
+          onlyLocales: data.onlyLocales
+        } : {}
+      }
+    });
+    return toRow3(row);
+  }
+  async delete(id) {
+    await this.db.promotion.delete({
+      where: {
+        id
+      }
+    });
+  }
+};
+PrismaPromotionRepository = _ts_decorate24([
+  Injectable24(),
+  _ts_param22(0, Inject22(PRISMA_CLIENT_TOKEN)),
+  _ts_metadata22("design:type", Function),
+  _ts_metadata22("design:paramtypes", [
+    typeof PromotionRepositoryClient === "undefined" ? Object : PromotionRepositoryClient
+  ])
+], PrismaPromotionRepository);
+function toPromotionValue(value) {
+  if (typeof value === "number") return value;
+  if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+    const obj = value;
+    return {
+      price: Number(obj.price),
+      months: Number(obj.months)
+    };
+  }
+  throw new Error(`Promotion.value has an unexpected shape: ${JSON.stringify(value)}`);
+}
+__name(toPromotionValue, "toPromotionValue");
+function toNullableStringArray(value) {
+  return Array.isArray(value) ? value : null;
+}
+__name(toNullableStringArray, "toNullableStringArray");
+function toPromotionI18n(value) {
+  if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+    return value;
+  }
+  return {};
+}
+__name(toPromotionI18n, "toPromotionI18n");
+function toRow3(row) {
+  return {
+    id: row.id,
+    projectKey: row.projectKey,
+    internalLabel: row.internalLabel,
+    type: row.type,
+    value: toPromotionValue(row.value),
+    appliesTo: toStringArray(row.appliesTo),
+    targetType: row.targetType,
+    billingCycle: row.billingCycle,
+    validFrom: row.validFrom.toISOString().slice(0, 10),
+    validTo: row.validTo.toISOString().slice(0, 10),
+    priority: row.priority,
+    onlyLocales: toNullableStringArray(row.onlyLocales),
+    requiresCoupon: row.requiresCoupon,
+    codes: toStringArray(row.codes),
+    color: row.color,
+    i18n: toPromotionI18n(row.i18n),
+    createdAt: row.createdAt.toISOString(),
+    updatedAt: row.updatedAt.toISOString()
+  };
+}
+__name(toRow3, "toRow");
+
+// src/prisma-subscription-contract.repository.ts
+import { Inject as Inject23, Injectable as Injectable25 } from "@nestjs/common";
+function _ts_decorate25(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_decorate25, "_ts_decorate");
+function _ts_metadata23(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata23, "_ts_metadata");
+function _ts_param23(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param23, "_ts_param");
+var ACTIVE_CONTRACT_STATUSES = [
+  "active",
+  "scheduled"
+];
+var PrismaSubscriptionContractRepository = class {
+  static {
+    __name(this, "PrismaSubscriptionContractRepository");
+  }
+  prisma;
+  constructor(prisma) {
+    this.prisma = prisma;
+  }
+  get db() {
+    return this.prisma;
+  }
+  async list(filter) {
+    const rows = await this.db.subscriptionContract.findMany({
+      where: {
+        ...filter.projectKey ? {
+          projectKey: filter.projectKey
+        } : {},
+        ...filter.tenantId ? {
+          tenantId: filter.tenantId
+        } : {},
+        ...filter.status ? {
+          status: filter.status
+        } : {},
+        ...filter.asOf ? {
+          effectiveFrom: {
+            lte: filter.asOf
+          },
+          OR: [
+            {
+              effectiveUntil: null
+            },
+            {
+              effectiveUntil: {
+                gt: filter.asOf
+              }
+            }
+          ]
+        } : {}
+      },
+      include: {
+        lineItems: true
+      },
+      orderBy: [
+        {
+          effectiveFrom: "desc"
+        },
+        {
+          createdAt: "desc"
+        }
+      ]
+    });
+    return rows.map(toRecord4);
+  }
+  async findById(contractId) {
+    const row = await this.db.subscriptionContract.findUnique({
+      where: {
+        id: contractId
+      },
+      include: {
+        lineItems: true
+      }
+    });
+    return row ? toRecord4(row) : null;
+  }
+  async findActiveByTenantId(tenantId, asOf = /* @__PURE__ */ new Date()) {
+    const row = await this.db.subscriptionContract.findFirst({
+      where: {
+        tenantId,
+        status: {
+          in: ACTIVE_CONTRACT_STATUSES
+        },
+        effectiveFrom: {
+          lte: asOf
+        },
+        OR: [
+          {
+            effectiveUntil: null
+          },
+          {
+            effectiveUntil: {
+              gt: asOf
+            }
+          }
+        ]
+      },
+      include: {
+        lineItems: true
+      },
+      orderBy: [
+        {
+          effectiveFrom: "desc"
+        },
+        {
+          createdAt: "desc"
+        }
+      ]
+    });
+    return row ? toRecord4(row) : null;
+  }
+  async create(data) {
+    const row = await this.db.subscriptionContract.create({
+      data: {
+        projectKey: data.projectKey,
+        tenantId: data.tenantId,
+        status: data.status ?? "active",
+        effectiveFrom: data.effectiveFrom,
+        effectiveUntil: data.effectiveUntil ?? null,
+        originalOfferId: data.originalOfferId ?? null,
+        originalPlanVersionId: data.originalPlanVersionId ?? null,
+        originalBundleVersionIds: data.originalBundleVersionIds ?? [],
+        priceSnapshot: data.priceSnapshot,
+        promotionSnapshots: data.promotionSnapshots ?? [],
+        promoCodeSnapshots: data.promoCodeSnapshots ?? [],
+        // Nullable JSON columns are omitted when absent so they stay SQL
+        // NULL (the DbNull sentinel is not available in this package).
+        ...data.entitlementSnapshot != null ? {
+          entitlementSnapshot: data.entitlementSnapshot
+        } : {},
+        ...data.termsSnapshot != null ? {
+          termsSnapshot: data.termsSnapshot
+        } : {},
+        lineItems: {
+          create: data.lineItems.map(toLineItemCreate)
+        }
+      },
+      include: {
+        lineItems: true
+      }
+    });
+    return toRecord4(row);
+  }
+  async terminate(contractId, data) {
+    const row = await this.db.subscriptionContract.update({
+      where: {
+        id: contractId
+      },
+      data: {
+        effectiveUntil: data.effectiveUntil,
+        status: data.status
+      },
+      include: {
+        lineItems: true
+      }
+    });
+    return toRecord4(row);
+  }
+};
+PrismaSubscriptionContractRepository = _ts_decorate25([
+  Injectable25(),
+  _ts_param23(0, Inject23(PRISMA_CLIENT_TOKEN)),
+  _ts_metadata23("design:type", Function),
+  _ts_metadata23("design:paramtypes", [
+    typeof PrismaLike === "undefined" ? Object : PrismaLike
+  ])
+], PrismaSubscriptionContractRepository);
+function toLineItemCreate(item) {
+  return {
+    kind: item.kind,
+    sourceKey: item.sourceKey,
+    sourceVersionId: item.sourceVersionId ?? null,
+    titleSnapshot: item.titleSnapshot,
+    descriptionSnapshot: item.descriptionSnapshot ?? null,
+    quantity: item.quantity,
+    unit: item.unit ?? null,
+    priceNet: item.priceNet,
+    priceGross: item.priceGross,
+    billingCycle: item.billingCycle,
+    minimumTermUntil: item.minimumTermUntil ?? null,
+    featuresSnapshot: item.featuresSnapshot,
+    quotaEffectsSnapshot: item.quotaEffectsSnapshot,
+    ...item.metadata != null ? {
+      metadata: item.metadata
+    } : {}
+  };
+}
+__name(toLineItemCreate, "toLineItemCreate");
+function isPlainObject2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+__name(isPlainObject2, "isPlainObject");
+function toUnknownArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+__name(toUnknownArray, "toUnknownArray");
+function toRecordOrNull(value) {
+  return isPlainObject2(value) ? value : null;
+}
+__name(toRecordOrNull, "toRecordOrNull");
+function toLineItem(row) {
+  return {
+    id: row.id,
+    contractId: row.contractId,
+    kind: row.kind,
+    sourceKey: row.sourceKey,
+    sourceVersionId: row.sourceVersionId,
+    titleSnapshot: row.titleSnapshot,
+    descriptionSnapshot: row.descriptionSnapshot,
+    quantity: row.quantity,
+    unit: row.unit,
+    priceNet: Number(row.priceNet),
+    priceGross: Number(row.priceGross),
+    billingCycle: row.billingCycle,
+    minimumTermUntil: row.minimumTermUntil,
+    featuresSnapshot: toStringArray(row.featuresSnapshot),
+    quotaEffectsSnapshot: toQuotaMap(row.quotaEffectsSnapshot),
+    metadata: toRecordOrNull(row.metadata),
+    createdAt: row.createdAt
+  };
+}
+__name(toLineItem, "toLineItem");
+function toRecord4(row) {
+  return {
+    id: row.id,
+    projectKey: row.projectKey,
+    tenantId: row.tenantId,
+    status: row.status,
+    effectiveFrom: row.effectiveFrom,
+    effectiveUntil: row.effectiveUntil,
+    originalOfferId: row.originalOfferId,
+    originalPlanVersionId: row.originalPlanVersionId,
+    originalBundleVersionIds: toStringArray(row.originalBundleVersionIds),
+    entitlementSnapshot: isPlainObject2(row.entitlementSnapshot) ? row.entitlementSnapshot : null,
+    priceSnapshot: row.priceSnapshot,
+    promotionSnapshots: toUnknownArray(row.promotionSnapshots),
+    promoCodeSnapshots: toUnknownArray(row.promoCodeSnapshots),
+    termsSnapshot: toRecordOrNull(row.termsSnapshot),
+    lineItems: row.lineItems.map(toLineItem),
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt
+  };
+}
+__name(toRecord4, "toRecord");
 export {
   AsyncLocalRlsBypassAdapter,
   PASSWORD_HASHER_TOKEN,
+  PRISMA_BUNDLE_REPOSITORY_OPTIONS,
   PRISMA_CLIENT_TOKEN,
+  PRISMA_SCHEMA_OPTIONS_TOKEN,
   PrismaAuditAdapter,
   PrismaAuditQueryAdapter,
   PrismaAuditStatsAdapter,
+  PrismaBundleRepository,
+  PrismaCatalogEntryRepository,
+  PrismaMarketingProjectionRepository,
+  PrismaMarketingSettingsRepository,
   PrismaMfaAdapter,
   PrismaPlanCatalogImportSink,
   PrismaPlanCatalogReadSink,
+  PrismaPlanRepository,
   PrismaPlanVersionRepository,
   PrismaPromoCodeRedemptionRepository,
   PrismaPromoCodeRepository,
   PrismaPromoCodeValidationLogRepository,
   PrismaPromoSubscriptionLookup,
+  PrismaPromotionRepository,
+  PrismaSubscriptionBundleRepository,
+  PrismaSubscriptionContractRepository,
   PrismaSubscriptionRepository,
   PrismaSuperAdminBootstrapAdapter,
+  PrismaTenantSubscriptionWriteAdapter,
   PrismaTransactionRunner,
   ZeroPromoRevenueDeductionAggregator,
   buildActorTag,
-  prismaPersistence
+  createPrismaPlanBindingResolver,
+  getPrismaDelegate,
+  prismaPersistence,
+  resolvePrismaSchemaOptions
 };